From 910fbdaff4f7260b92bb65aaed95b0a02598248c Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Mon, 11 Sep 2023 20:13:54 +0300
Subject: [PATCH 01/72] Add batch support for d1 driver

---
 drizzle-orm/package.json                 |   4 +-
 drizzle-orm/src/batch.ts                 |  33 ++
 drizzle-orm/src/d1/driver.ts             |  17 +-
 drizzle-orm/src/d1/session.ts            | 123 ++++-
 drizzle-orm/src/libsql/driver.ts         |  41 +-
 drizzle-orm/src/libsql/session.ts        |  28 +-
 integration-tests/tests/d1-batch.test.ts | 552 +++++++++++++++++++++++
 integration-tests/vitest.config.ts       |   2 +-
 pnpm-lock.yaml                           |  93 +---
 9 files changed, 741 insertions(+), 152 deletions(-)
 create mode 100644 drizzle-orm/src/batch.ts
 create mode 100644 integration-tests/tests/d1-batch.test.ts

diff --git a/drizzle-orm/package.json b/drizzle-orm/package.json
index bf768bdc5..b66c79824 100644
--- a/drizzle-orm/package.json
+++ b/drizzle-orm/package.json
@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.28.6",
+  "version": "0.28.7",
   "description": "Drizzle ORM package for SQL databases",
   "type": "module",
   "scripts": {
@@ -124,7 +124,7 @@
   },
   "devDependencies": {
     "@aws-sdk/client-rds-data": "^3.344.0",
-    "@cloudflare/workers-types": "^4.20230518.0",
+    "@cloudflare/workers-types": "^4.20230904.0",
     "@libsql/client": "^0.1.6",
     "@neondatabase/serverless": "^0.4.24",
     "@opentelemetry/api": "^1.4.1",
diff --git a/drizzle-orm/src/batch.ts b/drizzle-orm/src/batch.ts
new file mode 100644
index 000000000..72284914d
--- /dev/null
+++ b/drizzle-orm/src/batch.ts
@@ -0,0 +1,33 @@
+import type { SelectResult } from './query-builders/select.types.ts';
+import type { SQLiteDelete, SQLiteInsert, SQLiteSelect, SQLiteUpdate } from './sqlite-core/index.ts';
+import type { SQLiteRelationalQuery } from './sqlite-core/query-builders/query.ts';
+import type { SQLiteRaw } from './sqlite-core/query-builders/raw.ts';
+
+export type BatchParameters<TDriverResult = any> =
+	| SQLiteUpdate<any, 'async', TDriverResult, any>
+	| SQLiteSelect<any, 'async', TDriverResult, any, any>
+	| SQLiteDelete<any, 'async', TDriverResult, any>
+	| Omit<SQLiteDelete<any, 'async', TDriverResult, any>, 'where'>
+	| Omit<SQLiteUpdate<any, 'async', TDriverResult, any>, 'where'>
+	| SQLiteInsert<any, 'async', TDriverResult, any>
+	| SQLiteRelationalQuery<'async', any>
+	| SQLiteRaw<any>;
+
+export type BatchResponse<U extends BatchParameters, TQuery extends Readonly<[U, ...U[]]>> = {
+	[K in keyof TQuery]: TQuery[K] extends
+		SQLiteSelect<infer _TTable, 'async', infer _TRes, infer TSelection, infer TSelectMode, infer TNullabilityMap>
+		? SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+		: TQuery[K] extends SQLiteUpdate<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
+			? _TReturning extends undefined ? _TRunResult : _TReturning[]
+		: TQuery[K] extends Omit<SQLiteUpdate<infer _TTable, 'async', infer _TRunResult, infer _TReturning>, 'where'>
+			? _TReturning extends undefined ? _TRunResult : _TReturning[]
+		: TQuery[K] extends SQLiteInsert<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
+			? _TReturning extends undefined ? _TRunResult : _TReturning[]
+		: TQuery[K] extends SQLiteDelete<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
+			? _TReturning extends undefined ? _TRunResult : _TReturning[]
+		: TQuery[K] extends Omit<SQLiteDelete<infer _TTable, 'async', infer _TRunResult, infer _TReturning>, 'where'>
+			? _TReturning extends undefined ? _TRunResult : _TReturning[]
+		: TQuery[K] extends SQLiteRelationalQuery<'async', infer TResult> ? TResult
+		: TQuery[K] extends SQLiteRaw<infer TResult> ? TResult
+		: never;
+};
diff --git a/drizzle-orm/src/d1/driver.ts b/drizzle-orm/src/d1/driver.ts
index e4f32109e..2ba156b61 100644
--- a/drizzle-orm/src/d1/driver.ts
+++ b/drizzle-orm/src/d1/driver.ts
@@ -1,5 +1,4 @@
 /// <reference types="@cloudflare/workers-types" />
-
 import { DefaultLogger } from '~/logger.ts';
 import {
 	createTableRelationsHelpers,
@@ -11,10 +10,20 @@ import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { type DrizzleConfig } from '~/utils.ts';
 import { SQLiteD1Session } from './session.ts';
+import { entityKind } from '~/entity.ts';
+import type { BatchParameters, BatchResponse } from '~/batch.ts';
 
-export type DrizzleD1Database<
+export class DrizzleD1Database<
 	TSchema extends Record<string, unknown> = Record<string, never>,
-> = BaseSQLiteDatabase<'async', D1Result, TSchema>;
+> extends BaseSQLiteDatabase<'async', D1Result, TSchema> {
+	static readonly [entityKind]: string = 'LibSQLDatabase';
+
+	async batch<U extends BatchParameters<D1Result>, T extends Readonly<[U, ...U[]]>>(
+		batch: T,
+	): Promise<BatchResponse<U, T>> {
+		return await (this.session as SQLiteD1Session<TSchema, any>).batch(batch) as BatchResponse<U, T>;
+	}
+}
 
 export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
 	client: D1Database,
@@ -42,5 +51,5 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 	}
 
 	const session = new SQLiteD1Session(client, dialect, schema, { logger });
-	return new BaseSQLiteDatabase('async', dialect, session, schema) as DrizzleD1Database<TSchema>;
+	return new DrizzleD1Database('async', dialect, session, schema) as DrizzleD1Database<TSchema>;
 }
diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index d45731764..098714d71 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -1,13 +1,17 @@
 /// <reference types="@cloudflare/workers-types" />
 
-import { entityKind } from '~/entity.ts';
+import type { BatchParameters } from '~/batch.ts';
+import { entityKind, is } from '~/entity.ts';
+import { DrizzleError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
 import { type Query, sql } from '~/sql/index.ts';
 import { fillPlaceholders } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteTransaction } from '~/sqlite-core/index.ts';
+import { SQLiteDelete, SQLiteInsert, SQLiteSelect, SQLiteTransaction, SQLiteUpdate } from '~/sqlite-core/index.ts';
+import { SQLiteRelationalQuery } from '~/sqlite-core/query-builders/query.ts';
+import { SQLiteRaw } from '~/sqlite-core/query-builders/raw.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
 import {
 	type PreparedQueryConfig as PreparedQueryConfigBase,
@@ -51,6 +55,97 @@ export class SQLiteD1Session<
 		return new PreparedQuery(stmt, query.sql, query.params, this.logger, fields, executeMethod, customResultMapper);
 	}
 
+	private d1ToRawMapping(results: any) {
+		const rows: unknown[][] = [];
+		for (const row of results) {
+			const entry = Object.keys(row).map((k) => row[k]);
+			rows.push(entry);
+		}
+		return rows;
+	}
+
+	/*override */ batch<U extends BatchParameters, T extends Readonly<[U, ...U[]]>>(queries: T) {
+		const queryToType: (
+			| { mode: 'all' }
+			| {
+				mode: 'all_mapped';
+				config: { fields: SelectedFieldsOrdered; joinsNotNullableMap?: Record<string, boolean> };
+			}
+			| { mode: 'get' }
+			| { mode: 'values' }
+			| { mode: 'raw' }
+			| { mode: 'rqb'; mapper: any }
+		)[] = [];
+
+		const builtQueries: D1PreparedStatement[] = queries.map((query) => {
+			if (is(query, SQLiteSelect<any, 'async', any, any, any>)) {
+				const prepared = query.prepare() as PreparedQuery;
+				prepared.fields === undefined
+					? queryToType.push({ mode: 'all' })
+					: queryToType.push({
+						mode: 'all_mapped',
+						config: { fields: prepared.fields, joinsNotNullableMap: prepared.joinsNotNullableMap },
+					});
+				return prepared.stmt.bind(...prepared.params);
+			} else if (
+				is(query, SQLiteInsert<any, 'async', any, any>) || is(query, SQLiteUpdate<any, 'async', any, any>)
+				|| is(query, SQLiteDelete<any, 'async', any, any>)
+			) {
+				const prepared = query.prepare() as PreparedQuery;
+				queryToType.push(
+					query.config.returning
+						? {
+							mode: 'all_mapped',
+							config: { fields: query.config.returning },
+						}
+						: { mode: 'raw' },
+				);
+				return prepared.stmt.bind(...prepared.params);
+			} else if (is(query, SQLiteRaw)) {
+				const builtQuery = this.dialect.sqlToQuery(query.getSQL());
+				queryToType.push(
+					query.config.action === 'run' ? { mode: 'raw' } : { mode: query.config.action },
+				);
+				return this.client.prepare(builtQuery.sql).bind(...builtQuery.params);
+			} else if (is(query, SQLiteRelationalQuery)) {
+				const preparedRqb = query.prepare() as PreparedQuery;
+				queryToType.push({ mode: 'rqb', mapper: preparedRqb.customResultMapper });
+				return preparedRqb.stmt.bind(...preparedRqb.params);
+			}
+			throw new DrizzleError('You can use only drizzle queries in D1 batch api');
+		});
+
+		const res = this.client.batch<any>(builtQueries).then((stmt) =>
+			stmt.map(({ results }, index) => {
+				const action = queryToType[index]!;
+				if (action.mode === 'all') {
+					return results![0];
+				}
+				if (action.mode === 'all_mapped') {
+					const mappedRows = this.d1ToRawMapping(results);
+					return mappedRows!.map((row) => {
+						return mapResultRow(
+							action.config.fields,
+							row,
+							action.config.joinsNotNullableMap,
+						);
+					});
+				}
+				if (action.mode === 'get') {
+					return results[0] as unknown[];
+				}
+				if (action.mode === 'values') {
+					return this.d1ToRawMapping(results);
+				}
+				if (action.mode === 'raw') {
+					return stmt[index];
+				}
+				return action.mapper(this.d1ToRawMapping(results));
+			})
+		);
+		return res;
+	}
+
 	override async transaction<T>(
 		transaction: (tx: D1Transaction<TFullSchema, TSchema>) => T | Promise<T>,
 		config?: SQLiteTransactionConfig,
@@ -94,16 +189,32 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 > {
 	static readonly [entityKind]: string = 'D1PreparedQuery';
 
+	/** @internal */
+	customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown;
+
+	/** @internal */
+	fields?: SelectedFieldsOrdered;
+
+	/** @internal */
+	params: unknown[];
+
+	/** @internal */
+	stmt: D1PreparedStatement;
+
 	constructor(
-		private stmt: D1PreparedStatement,
+		stmt: D1PreparedStatement,
 		private queryString: string,
-		private params: unknown[],
+		params: unknown[],
 		private logger: Logger,
-		private fields: SelectedFieldsOrdered | undefined,
+		fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
-		private customResultMapper?: (rows: unknown[][]) => unknown,
+		customResultMapper?: (rows: unknown[][]) => unknown,
 	) {
 		super('async', executeMethod);
+		this.customResultMapper = customResultMapper;
+		this.fields = fields;
+		this.stmt = stmt;
+		this.params = params;
 	}
 
 	run(placeholderValues?: Record<string, unknown>): Promise<D1Result> {
diff --git a/drizzle-orm/src/libsql/driver.ts b/drizzle-orm/src/libsql/driver.ts
index 2f4bc5c58..44480f9f9 100644
--- a/drizzle-orm/src/libsql/driver.ts
+++ b/drizzle-orm/src/libsql/driver.ts
@@ -1,7 +1,6 @@
 import type { Client, ResultSet } from '@libsql/client';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
-import type { SelectResult } from '~/query-builders/select.types.ts';
 import {
 	createTableRelationsHelpers,
 	extractTablesRelationalConfig,
@@ -10,52 +9,16 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import type {
-	SQLiteDelete,
-	SQLiteInsert,
-	SQLiteSelect,
-	SQLiteUpdate,
-} from '~/sqlite-core/index.ts';
-import type { SQLiteRelationalQuery } from '~/sqlite-core/query-builders/query.ts';
-import type { SQLiteRaw } from '~/sqlite-core/query-builders/raw.ts';
 import { type DrizzleConfig } from '~/utils.ts';
 import { LibSQLSession } from './session.ts';
-
-export type BatchParameters =
-	| SQLiteUpdate<any, 'async', ResultSet, any>
-	| SQLiteSelect<any, 'async', ResultSet, any, any>
-	| SQLiteDelete<any, 'async', ResultSet, any>
-	| Omit<SQLiteDelete<any, 'async', ResultSet, any>, 'where'>
-	| Omit<SQLiteUpdate<any, 'async', ResultSet, any>, 'where'>
-	| SQLiteInsert<any, 'async', ResultSet, any>
-	| SQLiteRelationalQuery<'async', any>
-	| SQLiteRaw<any>;
-
-export type BatchResponse<U extends BatchParameters, TQuery extends Readonly<[U, ...U[]]>> = {
-	[K in keyof TQuery]: TQuery[K] extends
-		SQLiteSelect<infer _TTable, 'async', infer _TRes, infer TSelection, infer TSelectMode, infer TNullabilityMap>
-		? SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-		: TQuery[K] extends SQLiteUpdate<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends Omit<SQLiteUpdate<infer _TTable, 'async', infer _TRunResult, infer _TReturning>, 'where'>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends SQLiteInsert<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends SQLiteDelete<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends Omit<SQLiteDelete<infer _TTable, 'async', infer _TRunResult, infer _TReturning>, 'where'>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends SQLiteRelationalQuery<'async', infer TResult> ? TResult
-		: TQuery[K] extends SQLiteRaw<infer TResult> ? TResult
-		: never;
-};
+import type { BatchParameters, BatchResponse } from '~/batch.ts';
 
 export class LibSQLDatabase<
 	TSchema extends Record<string, unknown> = Record<string, never>,
 > extends BaseSQLiteDatabase<'async', ResultSet, TSchema> {
 	static readonly [entityKind]: string = 'LibSQLDatabase';
 
-	async batch<U extends BatchParameters, T extends Readonly<[U, ...U[]]>>(
+	async batch<U extends BatchParameters<ResultSet>, T extends Readonly<[U, ...U[]]>>(
 		batch: T,
 	): Promise<BatchResponse<U, T>> {
 		return await (this.session as LibSQLSession<TSchema, any>).batch(batch) as BatchResponse<U, T>;
diff --git a/drizzle-orm/src/libsql/session.ts b/drizzle-orm/src/libsql/session.ts
index f862ac4ad..fadb91b6c 100644
--- a/drizzle-orm/src/libsql/session.ts
+++ b/drizzle-orm/src/libsql/session.ts
@@ -1,4 +1,5 @@
 import { type Client, type InArgs, type InStatement, type ResultSet, type Transaction } from '@libsql/client';
+import type { BatchParameters } from '~/batch.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
@@ -16,7 +17,6 @@ import {
 } from '~/sqlite-core/session.ts';
 import { PreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
-import type { BatchParameters } from './driver.ts';
 
 export interface LibSQLSessionOptions {
 	logger?: Logger;
@@ -74,11 +74,10 @@ export class LibSQLSession<
 			| { mode: 'rqb'; mapper: any }
 		)[] = [];
 
-		const builtQueries: InStatement[] = queries.map((query) => {
+		const builtQueries: InStatement[] = queries.map((query: BatchParameters) => {
 			const builtQuery = this.dialect.sqlToQuery(query.getSQL());
 
-			if (is(query, SQLiteSelect)) {
-				// @ts-expect-error
+			if (is(query, SQLiteSelect<any, 'async', any, any, any>)) {
 				const prepared = query.prepare() as PreparedQuery;
 				prepared.fields === undefined
 					? queryToType.push({ mode: 'all' })
@@ -86,9 +85,19 @@ export class LibSQLSession<
 						mode: 'all_mapped',
 						config: { fields: prepared.fields, joinsNotNullableMap: prepared.joinsNotNullableMap },
 					});
-			} else if (is(query, SQLiteInsert) || is(query, SQLiteUpdate) || is(query, SQLiteDelete)) {
+			} else if (is(query, SQLiteRaw)) {
+				queryToType.push(
+					query.config.action === 'run' ? { mode: 'raw' } : { mode: query.config.action },
+				);
+			} else if (is(query, SQLiteRelationalQuery)) {
+				const preparedRqb = query.prepare() as PreparedQuery;
+				queryToType.push({ mode: 'rqb', mapper: preparedRqb.customResultMapper });
+			} else if (
+				is(query, SQLiteInsert<any, 'async', any, any>)
+				|| is(query, SQLiteUpdate<any, 'async', any, any>)
+				|| is(query, SQLiteDelete<any, 'async', any, any>)
+			) {
 				queryToType.push(
-					// @ts-expect-error
 					query.config.returning
 						? {
 							mode: 'all_mapped',
@@ -96,13 +105,6 @@ export class LibSQLSession<
 						}
 						: { mode: 'raw' },
 				);
-			} else if (is(query, SQLiteRaw)) {
-				queryToType.push(
-					query.config.action === 'run' ? { mode: 'raw' } : { mode: query.config.action },
-				);
-			} else if (is(query, SQLiteRelationalQuery)) {
-				const preparedRqb = query.prepare() as PreparedQuery;
-				queryToType.push({ mode: 'rqb', mapper: preparedRqb.customResultMapper });
 			}
 
 			return { sql: builtQuery.sql, args: builtQuery.params as InArgs };
diff --git a/integration-tests/tests/d1-batch.test.ts b/integration-tests/tests/d1-batch.test.ts
new file mode 100644
index 000000000..0b323149d
--- /dev/null
+++ b/integration-tests/tests/d1-batch.test.ts
@@ -0,0 +1,552 @@
+import 'dotenv/config';
+import { D1Database, D1DatabaseAPI } from '@miniflare/d1';
+import { createSQLiteDB } from '@miniflare/shared';
+import { eq, relations, sql } from 'drizzle-orm';
+import type { DrizzleD1Database } from 'drizzle-orm/d1';
+import { drizzle } from 'drizzle-orm/d1';
+import { type AnySQLiteColumn, integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { afterAll, beforeAll, beforeEach, expect, expectTypeOf, test } from 'vitest';
+
+const ENABLE_LOGGING = false;
+
+export const usersTable = sqliteTable('users', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	name: text('name').notNull(),
+	verified: integer('verified').notNull().default(0),
+	invitedBy: integer('invited_by').references((): AnySQLiteColumn => usersTable.id),
+});
+export const usersConfig = relations(usersTable, ({ one, many }) => ({
+	invitee: one(usersTable, {
+		fields: [usersTable.invitedBy],
+		references: [usersTable.id],
+	}),
+	usersToGroups: many(usersToGroupsTable),
+	posts: many(postsTable),
+}));
+
+export const groupsTable = sqliteTable('groups', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	name: text('name').notNull(),
+	description: text('description'),
+});
+export const groupsConfig = relations(groupsTable, ({ many }) => ({
+	usersToGroups: many(usersToGroupsTable),
+}));
+
+export const usersToGroupsTable = sqliteTable(
+	'users_to_groups',
+	{
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		userId: integer('user_id', { mode: 'number' }).notNull().references(
+			() => usersTable.id,
+		),
+		groupId: integer('group_id', { mode: 'number' }).notNull().references(
+			() => groupsTable.id,
+		),
+	},
+	(t) => ({
+		pk: primaryKey(t.userId, t.groupId),
+	}),
+);
+export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({
+	group: one(groupsTable, {
+		fields: [usersToGroupsTable.groupId],
+		references: [groupsTable.id],
+	}),
+	user: one(usersTable, {
+		fields: [usersToGroupsTable.userId],
+		references: [usersTable.id],
+	}),
+}));
+
+export const postsTable = sqliteTable('posts', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	content: text('content').notNull(),
+	ownerId: integer('owner_id', { mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	createdAt: integer('created_at', { mode: 'timestamp_ms' })
+		.notNull().default(sql`current_timestamp`),
+});
+export const postsConfig = relations(postsTable, ({ one, many }) => ({
+	author: one(usersTable, {
+		fields: [postsTable.ownerId],
+		references: [usersTable.id],
+	}),
+	comments: many(commentsTable),
+}));
+
+export const commentsTable = sqliteTable('comments', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	content: text('content').notNull(),
+	creator: integer('creator', { mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	postId: integer('post_id', { mode: 'number' }).references(() => postsTable.id),
+	createdAt: integer('created_at', { mode: 'timestamp_ms' })
+		.notNull().default(sql`current_timestamp`),
+});
+export const commentsConfig = relations(commentsTable, ({ one, many }) => ({
+	post: one(postsTable, {
+		fields: [commentsTable.postId],
+		references: [postsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentsTable.creator],
+		references: [usersTable.id],
+	}),
+	likes: many(commentLikesTable),
+}));
+
+export const commentLikesTable = sqliteTable('comment_likes', {
+	id: integer('id').primaryKey({ autoIncrement: true }),
+	creator: integer('creator', { mode: 'number' }).references(
+		() => usersTable.id,
+	),
+	commentId: integer('comment_id', { mode: 'number' }).references(
+		() => commentsTable.id,
+	),
+	createdAt: integer('created_at', { mode: 'timestamp_ms' })
+		.notNull().default(sql`current_timestamp`),
+});
+export const commentLikesConfig = relations(commentLikesTable, ({ one }) => ({
+	comment: one(commentsTable, {
+		fields: [commentLikesTable.commentId],
+		references: [commentsTable.id],
+	}),
+	author: one(usersTable, {
+		fields: [commentLikesTable.creator],
+		references: [usersTable.id],
+	}),
+}));
+
+const schema = {
+	usersTable,
+	postsTable,
+	commentsTable,
+	usersToGroupsTable,
+	groupsTable,
+	commentLikesConfig,
+	commentsConfig,
+	postsConfig,
+	usersToGroupsConfig,
+	groupsConfig,
+	usersConfig,
+};
+
+let db: DrizzleD1Database<typeof schema>;
+
+beforeAll(async () => {
+	const sqliteDb = await createSQLiteDB(':memory:');
+	db = drizzle(new D1Database(new D1DatabaseAPI(sqliteDb)) as any, { schema, logger: ENABLE_LOGGING });
+});
+
+beforeEach(async () => {
+	await db.run(sql`drop table if exists \`groups\``);
+	await db.run(sql`drop table if exists \`users\``);
+	await db.run(sql`drop table if exists \`users_to_groups\``);
+	await db.run(sql`drop table if exists \`posts\``);
+	await db.run(sql`drop table if exists \`comments\``);
+	await db.run(sql`drop table if exists \`comment_likes\``);
+
+	await db.run(
+		sql`
+			CREATE TABLE \`users\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`verified\` integer DEFAULT 0 NOT NULL,
+			    \`invited_by\` integer
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`groups\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`name\` text NOT NULL,
+			    \`description\` text
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`users_to_groups\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`user_id\` integer NOT NULL,
+			    \`group_id\` integer NOT NULL
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`posts\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`owner_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`comments\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`content\` text NOT NULL,
+			    \`creator\` integer,
+			    \`post_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+	await db.run(
+		sql`
+			CREATE TABLE \`comment_likes\` (
+			    \`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+			    \`creator\` integer,
+			    \`comment_id\` integer,
+			    \`created_at\` integer DEFAULT current_timestamp NOT NULL
+			);
+		`,
+	);
+});
+
+afterAll(async () => {
+	await db.run(sql`drop table if exists \`groups\``);
+	await db.run(sql`drop table if exists \`users\``);
+	await db.run(sql`drop table if exists \`users_to_groups\``);
+	await db.run(sql`drop table if exists \`posts\``);
+	await db.run(sql`drop table if exists \`comments\``);
+	await db.run(sql`drop table if exists \`comment_likes\``);
+});
+
+test('batch api example', async () => {
+	const batchResponse = await db.batch([
+		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({
+			id: usersTable.id,
+			invitedBy: usersTable.invitedBy,
+		}),
+		db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+		db.select().from(usersTable),
+	]);
+
+	console.log('batchResponse', batchResponse);
+
+	expectTypeOf(batchResponse).toEqualTypeOf<[
+		{
+			id: number;
+			invitedBy: number | null;
+		}[],
+		D1Result,
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+	]>();
+
+	expect(batchResponse.length).eq(3);
+
+	expect(batchResponse[0]).toEqual([{
+		id: 1,
+		invitedBy: null,
+	}]);
+
+	// expect(batchResponse[1]).toEqual({
+	// 	results: [],
+	// 	success: true,
+	// 	meta: {
+	// 		duration: 0.027083873748779297,
+	// 		last_row_id: 2,
+	// 		changes: 1,
+	// 		served_by: 'miniflare.db',
+	// 		internal_stats: null,
+	// 	},
+	// });
+
+	expect(batchResponse[2]).toEqual([
+		{ id: 1, name: 'John', verified: 0, invitedBy: null },
+		{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+	]);
+});
+
+// batch api only relational many
+test('insert + findMany', async () => {
+	const batchResponse = await db.batch([
+		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+		db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+		db.query.usersTable.findMany({}),
+	]);
+
+	expectTypeOf(batchResponse).toEqualTypeOf<[
+		{
+			id: number;
+		}[],
+		D1Result,
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+	]>();
+
+	expect(batchResponse.length).eq(3);
+
+	expect(batchResponse[0]).toEqual([{
+		id: 1,
+	}]);
+
+	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+
+	expect(batchResponse[2]).toEqual([
+		{ id: 1, name: 'John', verified: 0, invitedBy: null },
+		{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+	]);
+});
+
+// batch api relational many + one
+test('insert + findMany + findFirst', async () => {
+	const batchResponse = await db.batch([
+		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+		db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+		db.query.usersTable.findMany({}),
+		db.query.usersTable.findFirst({}),
+	]);
+
+	expectTypeOf(batchResponse).toEqualTypeOf<[
+		{
+			id: number;
+		}[],
+		D1Result,
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		} | undefined,
+	]>();
+
+	expect(batchResponse.length).eq(4);
+
+	expect(batchResponse[0]).toEqual([{
+		id: 1,
+	}]);
+
+	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+
+	expect(batchResponse[2]).toEqual([
+		{ id: 1, name: 'John', verified: 0, invitedBy: null },
+		{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+	]);
+
+	expect(batchResponse[3]).toEqual(
+		{ id: 1, name: 'John', verified: 0, invitedBy: null },
+	);
+});
+
+test('insert + db.all + db.get + db.values + db.run', async () => {
+	const batchResponse = await db.batch([
+		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+		db.run(sql`insert into users (id, name) values (2, 'Dan')`),
+		db.all<typeof usersTable.$inferSelect>(sql`select * from users`),
+		db.values(sql`select * from users`),
+		db.get<typeof usersTable.$inferSelect>(sql`select * from users`),
+	]);
+
+	expectTypeOf(batchResponse).toEqualTypeOf<[
+		{
+			id: number;
+		}[],
+		D1Result,
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+		unknown[][],
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		},
+	]>();
+
+	expect(batchResponse.length).eq(5);
+
+	expect(batchResponse[0], 'insert').toEqual([{
+		id: 1,
+	}]);
+
+	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+
+	expect(batchResponse[2], 'all').toEqual([
+		{ id: 1, name: 'John', verified: 0, invited_by: null },
+		{ id: 2, name: 'Dan', verified: 0, invited_by: null },
+	]);
+
+	expect(batchResponse[3], 'values').toEqual([[1, 'John', 0, null], [2, 'Dan', 0, null]]);
+
+	expect(batchResponse[4], 'get').toEqual(
+		{ id: 1, name: 'John', verified: 0, invited_by: null },
+	);
+});
+
+// batch api combined rqb + raw call
+test('insert + findManyWith + db.all', async () => {
+	const batchResponse = await db.batch([
+		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+		db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+		db.query.usersTable.findMany({}),
+		db.all<typeof usersTable.$inferSelect>(sql`select * from users`),
+	]);
+
+	expectTypeOf(batchResponse).toEqualTypeOf<[
+		{
+			id: number;
+		}[],
+		D1Result,
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+	]>();
+
+	expect(batchResponse.length).eq(4);
+
+	expect(batchResponse[0]).toEqual([{
+		id: 1,
+	}]);
+
+	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+
+	expect(batchResponse[2]).toEqual([
+		{ id: 1, name: 'John', verified: 0, invitedBy: null },
+		{ id: 2, name: 'Dan', verified: 0, invitedBy: null },
+	]);
+
+	expect(batchResponse[3]).toEqual([
+		{ id: 1, name: 'John', verified: 0, invited_by: null },
+		{ id: 2, name: 'Dan', verified: 0, invited_by: null },
+	]);
+});
+
+// batch api for insert + update + select
+test('insert + update + select + select partial', async () => {
+	const batchResponse = await db.batch([
+		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+		db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
+		db.query.usersTable.findMany({}),
+		db.select().from(usersTable).where(eq(usersTable.id, 1)),
+		db.select({ id: usersTable.id, invitedBy: usersTable.invitedBy }).from(usersTable),
+	]);
+
+	expectTypeOf(batchResponse).toEqualTypeOf<[
+		{
+			id: number;
+		}[],
+		D1Result,
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+		{
+			id: number;
+			name: string;
+			verified: number;
+			invitedBy: number | null;
+		}[],
+		{
+			id: number;
+			invitedBy: number | null;
+		}[],
+	]>();
+
+	expect(batchResponse.length).eq(5);
+
+	expect(batchResponse[0]).toEqual([{
+		id: 1,
+	}]);
+
+	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 1n });
+
+	expect(batchResponse[2]).toEqual([
+		{ id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	]);
+
+	expect(batchResponse[3]).toEqual([
+		{ id: 1, name: 'Dan', verified: 0, invitedBy: null },
+	]);
+
+	expect(batchResponse[4]).toEqual([
+		{ id: 1, invitedBy: null },
+	]);
+});
+
+// batch api for insert + delete + select
+test('insert + delete + select + select partial', async () => {
+	const batchResponse = await db.batch([
+		db.insert(usersTable).values({ id: 1, name: 'John' }).returning({ id: usersTable.id }),
+		db.insert(usersTable).values({ id: 2, name: 'Dan' }),
+		db.delete(usersTable).where(eq(usersTable.id, 1)).returning({ id: usersTable.id, invitedBy: usersTable.invitedBy }),
+		db.query.usersTable.findFirst({
+			columns: {
+				id: true,
+				invitedBy: true,
+			},
+		}),
+	]);
+
+	expectTypeOf(batchResponse).toEqualTypeOf<[
+		{
+			id: number;
+		}[],
+		D1Result,
+		{
+			id: number;
+			invitedBy: number | null;
+		}[],
+		{
+			id: number;
+			invitedBy: number | null;
+		} | undefined,
+	]>();
+
+	expect(batchResponse.length).eq(4);
+
+	expect(batchResponse[0]).toEqual([{
+		id: 1,
+	}]);
+
+	// expect(batchResponse[1]).toEqual({ columns: [], rows: [], rowsAffected: 1, lastInsertRowid: 2n });
+
+	expect(batchResponse[2]).toEqual([
+		{ id: 1, invitedBy: null },
+	]);
+
+	expect(batchResponse[3]).toEqual(
+		{ id: 2, invitedBy: null },
+	);
+});
+
+// * additionally
+// batch for all libsql cases, just replace simple calls with batch calls
+// batch for all rqb cases, just replace simple calls with batch calls
diff --git a/integration-tests/vitest.config.ts b/integration-tests/vitest.config.ts
index a9bee6e81..9a0089280 100644
--- a/integration-tests/vitest.config.ts
+++ b/integration-tests/vitest.config.ts
@@ -4,7 +4,7 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
 	test: {
-		include: ['tests/relational/**/*.test.ts', 'tests/libsql-batch.test.ts'],
+		include: ['tests/relational/**/*.test.ts', 'tests/libsql-batch.test.ts', 'tests/d1-batch.test.ts'],
 		exclude: [
 			...(process.env.SKIP_PLANETSCALE_TESTS ? ['tests/relational/mysql.planetscale.test.ts'] : []),
 			'tests/relational/vercel.test.ts',
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b2eaae777..20aac5a33 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -80,8 +80,8 @@ importers:
         specifier: ^3.344.0
         version: 3.344.0
       '@cloudflare/workers-types':
-        specifier: ^4.20230518.0
-        version: 4.20230518.0
+        specifier: ^4.20230904.0
+        version: 4.20230904.0
       '@libsql/client':
         specifier: ^0.1.6
         version: 0.1.6
@@ -174,10 +174,10 @@ importers:
         version: 3.12.7
       vite-tsconfig-paths:
         specifier: ^4.2.0
-        version: 4.2.0(typescript@5.1.6)
+        version: 4.2.0(typescript@5.1.6)(vite@4.3.9)
       vitest:
         specifier: ^0.31.4
-        version: 0.31.4
+        version: 0.31.4(@vitest/ui@0.31.4)
       zod:
         specifier: ^3.20.2
         version: 3.21.4
@@ -1581,8 +1581,8 @@ packages:
     resolution: {integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==}
     dev: false
 
-  /@cloudflare/workers-types@4.20230518.0:
-    resolution: {integrity: sha512-A0w1V+5SUawGaaPRlhFhSC/SCDT9oQG8TMoWOKFLA4qbqagELqEAFD4KySBIkeVOvCBLT1DZSYBMCxbXddl0kw==}
+  /@cloudflare/workers-types@4.20230904.0:
+    resolution: {integrity: sha512-IX4oJCe14ctblSPZBlW64BVZ9nYLUo6sD2I5gu3hX0ywByYWm1OuoKm9Xb/Zpbj8Ph18Z7Ryii6u2/ocnncXdA==}
     dev: true
 
   /@dprint/darwin-arm64@0.40.2:
@@ -8358,22 +8358,6 @@ packages:
       - supports-color
       - terser
 
-  /vite-tsconfig-paths@4.2.0(typescript@5.1.6):
-    resolution: {integrity: sha512-jGpus0eUy5qbbMVGiTxCL1iB9ZGN6Bd37VGLJU39kTDD6ZfULTTb1bcc5IeTWqWJKiWV5YihCaibeASPiGi8kw==}
-    peerDependencies:
-      vite: '*'
-    peerDependenciesMeta:
-      vite:
-        optional: true
-    dependencies:
-      debug: 4.3.4
-      globrex: 0.1.2
-      tsconfck: 2.1.1(typescript@5.1.6)
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-    dev: true
-
   /vite-tsconfig-paths@4.2.0(typescript@5.1.6)(vite@4.3.9):
     resolution: {integrity: sha512-jGpus0eUy5qbbMVGiTxCL1iB9ZGN6Bd37VGLJU39kTDD6ZfULTTb1bcc5IeTWqWJKiWV5YihCaibeASPiGi8kw==}
     peerDependencies:
@@ -8423,71 +8407,6 @@ packages:
     optionalDependencies:
       fsevents: 2.3.3
 
-  /vitest@0.31.4:
-    resolution: {integrity: sha512-GoV0VQPmWrUFOZSg3RpQAPN+LPmHg2/gxlMNJlyxJihkz6qReHDV6b0pPDcqFLNEPya4tWJ1pgwUNP9MLmUfvQ==}
-    engines: {node: '>=v14.18.0'}
-    hasBin: true
-    peerDependencies:
-      '@edge-runtime/vm': '*'
-      '@vitest/browser': '*'
-      '@vitest/ui': '*'
-      happy-dom: '*'
-      jsdom: '*'
-      playwright: '*'
-      safaridriver: '*'
-      webdriverio: '*'
-    peerDependenciesMeta:
-      '@edge-runtime/vm':
-        optional: true
-      '@vitest/browser':
-        optional: true
-      '@vitest/ui':
-        optional: true
-      happy-dom:
-        optional: true
-      jsdom:
-        optional: true
-      playwright:
-        optional: true
-      safaridriver:
-        optional: true
-      webdriverio:
-        optional: true
-    dependencies:
-      '@types/chai': 4.3.5
-      '@types/chai-subset': 1.3.3
-      '@types/node': 20.2.5
-      '@vitest/expect': 0.31.4
-      '@vitest/runner': 0.31.4
-      '@vitest/snapshot': 0.31.4
-      '@vitest/spy': 0.31.4
-      '@vitest/utils': 0.31.4
-      acorn: 8.8.2
-      acorn-walk: 8.2.0
-      cac: 6.7.14
-      chai: 4.3.7
-      concordance: 5.0.4
-      debug: 4.3.4
-      local-pkg: 0.4.3
-      magic-string: 0.30.0
-      pathe: 1.1.1
-      picocolors: 1.0.0
-      std-env: 3.3.3
-      strip-literal: 1.0.1
-      tinybench: 2.5.0
-      tinypool: 0.5.0
-      vite: 4.3.9(@types/node@20.2.5)
-      vite-node: 0.31.4(@types/node@20.2.5)
-      why-is-node-running: 2.2.2
-    transitivePeerDependencies:
-      - less
-      - sass
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-    dev: true
-
   /vitest@0.31.4(@vitest/ui@0.31.4):
     resolution: {integrity: sha512-GoV0VQPmWrUFOZSg3RpQAPN+LPmHg2/gxlMNJlyxJihkz6qReHDV6b0pPDcqFLNEPya4tWJ1pgwUNP9MLmUfvQ==}
     engines: {node: '>=v14.18.0'}

From 88d4bc7ee37a32e7ee9ddcbe6fd9d3e79b07a417 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Mon, 11 Sep 2023 20:19:28 +0300
Subject: [PATCH 02/72] Remove d1 batch tests from ava runner

---
 integration-tests/package.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/integration-tests/package.json b/integration-tests/package.json
index 879ea4a9a..aeb2b6792 100644
--- a/integration-tests/package.json
+++ b/integration-tests/package.json
@@ -21,7 +21,8 @@
       "!tests/bun/**/*",
       "!tests/vercel-pg.test.ts",
       "!tests/relational/**/*",
-      "!tests/libsql-batch.test.ts"
+      "!tests/libsql-batch.test.ts",
+      "!tests/d1-batch.test.ts"
     ],
     "extensions": {
       "ts": "module"

From d3fbe4adbd8105eb28fcf71d5c7ebfa70d593b44 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Wed, 13 Sep 2023 21:36:36 +0300
Subject: [PATCH 03/72] Update all function handling in d1 batch

---
 drizzle-orm/src/d1/session.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index 098714d71..a2f689e9b 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -119,7 +119,7 @@ export class SQLiteD1Session<
 			stmt.map(({ results }, index) => {
 				const action = queryToType[index]!;
 				if (action.mode === 'all') {
-					return results![0];
+					return results;
 				}
 				if (action.mode === 'all_mapped') {
 					const mappedRows = this.d1ToRawMapping(results);

From 092355c5d3b413c6ce47b4db53a1ceeea0f343ea Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Wed, 13 Sep 2023 21:52:26 +0300
Subject: [PATCH 04/72] Added 0.28.7 release notes to be ready for next release

---
 changelogs/drizzle-orm/0.28.7.md | 65 ++++++++++++++++++++++++++++++++
 drizzle-orm/src/d1/session.ts    |  6 +++
 2 files changed, 71 insertions(+)
 create mode 100644 changelogs/drizzle-orm/0.28.7.md

diff --git a/changelogs/drizzle-orm/0.28.7.md b/changelogs/drizzle-orm/0.28.7.md
new file mode 100644
index 000000000..0d07ea00f
--- /dev/null
+++ b/changelogs/drizzle-orm/0.28.7.md
@@ -0,0 +1,65 @@
+## New Features
+
+### 🎉 `D1` batch api support
+
+Reference: https://developers.cloudflare.com/d1/platform/client-api/#dbbatch
+
+Batch API usage example:
+
+```ts
+const batchResponse = await db.batch([
+	db.insert(usersTable).values({ id: 1, name: 'John' }).returning({
+		id: usersTable.id,
+	}),
+	db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
+	db.query.usersTable.findMany({}),
+	db.select().from(usersTable).where(eq(usersTable.id, 1)),
+	db.select({ id: usersTable.id, invitedBy: usersTable.invitedBy }).from(
+		usersTable,
+	),
+]);
+```
+
+Type for `batchResponse` in this example would be:
+
+```ts
+type BatchResponse = [
+	{
+		id: number;
+	}[],
+	D1Result,
+	{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[],
+	{
+		id: number;
+		name: string;
+		verified: number;
+		invitedBy: number | null;
+	}[],
+	{
+		id: number;
+		invitedBy: number | null;
+	}[],
+];
+```
+
+All possible builders that can be used inside `db.batch`:
+
+```ts
+`db.all()`,
+`db.get()`,
+`db.values()`,
+`db.run()`,
+`db.query.<table>.findMany()`,
+`db.query.<table>.findFirst()`,
+`db.select()...`,
+`db.update()...`,
+`db.delete()...`,
+`db.insert()...`,
+```
+
+More usage examples here: [integration-tests/tests/d1-batch.test.ts](https://github.com/drizzle-team/drizzle-orm/blob/beta/integration-tests/tests/d1-batch.test.ts) and in [docs](https://orm.drizzle.team/docs/batch-api)
\ No newline at end of file
diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index a2f689e9b..bfdfc9d60 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -55,6 +55,12 @@ export class SQLiteD1Session<
 		return new PreparedQuery(stmt, query.sql, query.params, this.logger, fields, executeMethod, customResultMapper);
 	}
 
+	/**
+	 * This function was taken from the D1 implementation: https://github.com/cloudflare/workerd/blob/4aae9f4c7ae30a59a88ca868c4aff88bda85c956/src/cloudflare/internal/d1-api.ts#L287
+	 * It may cause issues with duplicated column names in join queries, which should be fixed on the D1 side.
+	 * @param results
+	 * @returns
+	 */
 	private d1ToRawMapping(results: any) {
 		const rows: unknown[][] = [];
 		for (const row of results) {

From 26db5896896f0f12e2176d2964171a69234a524e Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Wed, 13 Sep 2023 20:33:52 -0400
Subject: [PATCH 05/72] (Mysql) Initial implementation of Set Operations
 support

Added a new file set-operators.ts with a SetOperatorQueryBuilder class and a SetOperator class

The MySqlSelectBuilder now extends the SetOperatorQueryBuilder to inherit the set operator methods

Added the export for the set operation functions
---
 .../src/mysql-core/query-builders/index.ts    |   1 +
 .../src/mysql-core/query-builders/select.ts   |  11 +-
 .../query-builders/set-operators.ts           | 536 ++++++++++++++++++
 3 files changed, 544 insertions(+), 4 deletions(-)
 create mode 100644 drizzle-orm/src/mysql-core/query-builders/set-operators.ts

diff --git a/drizzle-orm/src/mysql-core/query-builders/index.ts b/drizzle-orm/src/mysql-core/query-builders/index.ts
index 16f0e1d4d..58d909c22 100644
--- a/drizzle-orm/src/mysql-core/query-builders/index.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/index.ts
@@ -3,4 +3,5 @@ export * from './insert.ts';
 export * from './query-builder.ts';
 export * from './select.ts';
 export * from './select.types.ts';
+export * from './set-operators.ts';
 export * from './update.ts';
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.ts b/drizzle-orm/src/mysql-core/query-builders/select.ts
index c93d97468..4e73b24d8 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.ts
@@ -10,7 +10,6 @@ import type {
 import type { SubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
 import { MySqlViewBase } from '~/mysql-core/view.ts';
-import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
 	GetSelectTableName,
@@ -37,6 +36,7 @@ import type {
 	MySqlSelectQueryBuilderHKT,
 	SelectedFields,
 } from './select.types.ts';
+import { MySqlSetOperatorBuilder } from './set-operators.ts';
 
 type CreateMySqlSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
@@ -128,9 +128,12 @@ export abstract class MySqlSelectQueryBuilder<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> extends MySqlSetOperatorBuilder<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	PreparedQueryHKTBase,
+	TNullabilityMap
 > {
 	static readonly [entityKind]: string = 'MySqlSelectQueryBuilder';
 
diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
new file mode 100644
index 000000000..317ff0651
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -0,0 +1,536 @@
+import { entityKind, is } from '~/entity.ts';
+import {
+	applyMixins,
+	orderSelectedFields,
+	type Placeholder,
+	type Query,
+	QueryPromise,
+	SelectionProxyHandler,
+	SQL,
+	sql,
+	type ValueOrArray,
+} from '~/index.ts';
+import type {
+	MySqlSession,
+	PreparedQueryConfig,
+	PreparedQueryHKTBase,
+	PreparedQueryKind,
+} from '~/mysql-core/session.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import { type ColumnsSelection } from '~/view.ts';
+import { MySqlColumn } from '../columns/common.ts';
+import type { MySqlDialect } from '../dialect.ts';
+
+type SetOperator = 'union' | 'intersect' | 'except';
+
+export interface MySqlSetOperatorBuilder<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends
+	TypedQueryBuilder<
+		BuildSubquerySelection<TSelection, TNullabilityMap>,
+		SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+	>,
+	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+{}
+
+export abstract class MySqlSetOperatorBuilder<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends TypedQueryBuilder<
+	BuildSubquerySelection<TSelection, TNullabilityMap>,
+	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> {
+	static readonly [entityKind]: string = 'MySqlSetOperatorBuilder';
+
+	protected abstract joinsNotNullableMap: Record<string, boolean>;
+	protected abstract config: {
+		fields: Record<string, unknown>;
+		limit?: number | Placeholder;
+		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+	};
+	/* @internal */
+	abstract readonly session: MySqlSession | undefined;
+	protected abstract dialect: MySqlDialect;
+
+	/** @internal */
+	getSetOperatorConfig() {
+		return {
+			session: this.session,
+			dialect: this.dialect,
+			joinsNotNullableMap: this.joinsNotNullableMap,
+			fields: this.config.fields,
+		};
+	}
+
+	union(
+		rightSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+	): MySqlSetOperator<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT
+	> {
+		return new MySqlSetOperator('union', false, this, rightSelect) as any;
+	}
+
+	unionAll(
+		rightSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+	): MySqlSetOperator<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT
+	> {
+		return new MySqlSetOperator('union', true, this, rightSelect) as any;
+	}
+
+	intersect(
+		rightSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+	): MySqlSetOperator<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT
+	> {
+		return new MySqlSetOperator('intersect', false, this, rightSelect) as any;
+	}
+
+	intersectAll(
+		rightSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+	): MySqlSetOperator<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT
+	> {
+		return new MySqlSetOperator('intersect', true, this, rightSelect) as any;
+	}
+
+	except(
+		rightSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+	): MySqlSetOperator<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT
+	> {
+		return new MySqlSetOperator('except', false, this, rightSelect) as any;
+	}
+
+	exceptAll(
+		rightSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+	): MySqlSetOperator<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT
+	> {
+		return new MySqlSetOperator('except', true, this, rightSelect) as any;
+	}
+
+	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): this;
+	abstract orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): this;
+
+	abstract limit(limit: number): this;
+}
+
+export class MySqlSetOperator<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends MySqlSetOperatorBuilder<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap
+> {
+	static readonly [entityKind]: string = 'MySqlSetOperator';
+
+	protected joinsNotNullableMap: Record<string, boolean>;
+	protected config: {
+		fields: Record<string, unknown>;
+		limit?: number | Placeholder;
+		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+	};
+	/* @internal */
+	readonly session: MySqlSession | undefined;
+	protected dialect: MySqlDialect;
+
+	constructor(
+		private operator: SetOperator,
+		private isAll: boolean,
+		private leftSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+		private rightSelect: MySqlSetOperatorBuilder<
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap
+		>,
+	) {
+		super();
+		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
+		this.session = session;
+		this.dialect = dialect;
+		this.joinsNotNullableMap = joinsNotNullableMap;
+		this.config = {
+			fields,
+		};
+	}
+
+	orderBy(
+		...columns:
+			| [(aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
+			| (MySqlColumn | SQL | SQL.Aliased)[]
+	) {
+		if (typeof columns[0] === 'function') {
+			const orderBy = columns[0](
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+		} else {
+			this.config.orderBy = columns as (MySqlColumn | SQL | SQL.Aliased)[];
+		}
+		return this;
+	}
+
+	limit(limit: number) {
+		this.config.limit = limit;
+		return this;
+	}
+
+	override getSQL(): SQL<unknown> {
+		const leftChunk = sql`(${this.leftSelect.getSQL()}) `;
+		const rightChunk = sql`(${this.rightSelect.getSQL()})`;
+
+		let orderBySql;
+		if (this.config.orderBy && this.config.orderBy.length > 0) {
+			const orderByValues: SQL<unknown>[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const orderBy of this.config.orderBy) {
+				if (is(orderBy, MySqlColumn)) {
+					orderByValues.push(sql.raw(orderBy.name));
+				} else if (is(orderBy, SQL)) {
+					for (let i = 0; i < orderBy.queryChunks.length; i++) {
+						const chunk = orderBy.queryChunks[i];
+
+						if (is(chunk, MySqlColumn)) {
+							orderBy.queryChunks[i] = sql.raw(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${orderBy}`);
+				} else {
+					orderByValues.push(sql`${orderBy}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
+		}
+
+		const limitSql = this.config.limit ? sql` limit ${this.config.limit}` : undefined;
+
+		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}`;
+	}
+
+	toSQL(): Query {
+		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+		return rest;
+	}
+
+	prepare() {
+		if (!this.session) {
+			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
+		}
+		const fieldsList = orderSelectedFields<MySqlColumn>(this.config.fields);
+		const query = this.session.prepareQuery<
+			PreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] },
+			TPreparedQueryHKT
+		>(this.dialect.sqlToQuery(this.getSQL()), fieldsList);
+		query.joinsNotNullableMap = this.joinsNotNullableMap;
+		return query as PreparedQueryKind<
+			TPreparedQueryHKT,
+			PreparedQueryConfig & {
+				execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+				iterator: SelectResult<TSelection, TSelectMode, TNullabilityMap>;
+			},
+			true
+		>;
+	}
+
+	execute = ((placeholderValues) => {
+		return this.prepare().execute(placeholderValues);
+	}) as ReturnType<this['prepare']>['execute'];
+
+	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
+		const self = this;
+		return async function*(placeholderValues) {
+			yield* self.prepare().iterator(placeholderValues);
+		};
+	};
+
+	iterator = this.createIterator();
+}
+
+applyMixins(MySqlSetOperatorBuilder, [QueryPromise]);
+
+export function union<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+>(
+	leftSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+	rightSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+): MySqlSetOperator<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap
+> {
+	return new MySqlSetOperator('union', false, leftSelect, rightSelect);
+}
+
+export function unionAll<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+>(
+	leftSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+	rightSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+): MySqlSetOperator<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap
+> {
+	return new MySqlSetOperator('union', true, leftSelect, rightSelect);
+}
+
+export function intersect<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+>(
+	leftSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+	rightSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+): MySqlSetOperator<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap
+> {
+	return new MySqlSetOperator('intersect', false, leftSelect, rightSelect);
+}
+
+export function intersectAll<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+>(
+	leftSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+	rightSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+): MySqlSetOperator<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap
+> {
+	return new MySqlSetOperator('intersect', true, leftSelect, rightSelect);
+}
+
+export function except<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+>(
+	leftSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+	rightSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+): MySqlSetOperator<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap
+> {
+	return new MySqlSetOperator('except', false, leftSelect, rightSelect);
+}
+
+export function exceptAll<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+>(
+	leftSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+	rightSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap
+	>,
+): MySqlSetOperator<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap
+> {
+	return new MySqlSetOperator('except', true, leftSelect, rightSelect);
+}

From 2899623d49417eb3580ba8fa6bb1180da27f2935 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Wed, 13 Sep 2023 20:36:48 -0400
Subject: [PATCH 06/72] Initial implementation of Set Operations support for
 postgres

This implementation will likely change with the same pattern used in the Mysql implementation
---
 .../src/pg-core/query-builders/index.ts       |   1 +
 .../src/pg-core/query-builders/select.ts      | 119 +++++++
 .../pg-core/query-builders/set-operators.ts   | 326 ++++++++++++++++++
 3 files changed, 446 insertions(+)
 create mode 100644 drizzle-orm/src/pg-core/query-builders/set-operators.ts

diff --git a/drizzle-orm/src/pg-core/query-builders/index.ts b/drizzle-orm/src/pg-core/query-builders/index.ts
index c4821e51d..fb3dd5931 100644
--- a/drizzle-orm/src/pg-core/query-builders/index.ts
+++ b/drizzle-orm/src/pg-core/query-builders/index.ts
@@ -4,4 +4,5 @@ export * from './query-builder.ts';
 export * from './refresh-materialized-view.ts';
 export * from './select.ts';
 export * from './select.types.ts';
+export * from './set-operators.ts';
 export * from './update.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index 7179a43eb..734de066e 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -33,6 +33,7 @@ import type {
 	PgSelectQueryBuilderHKT,
 	SelectedFields,
 } from './select.types.ts';
+import { PgSetOperator } from './set-operators.ts';
 
 type CreatePgSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
@@ -179,6 +180,16 @@ export abstract class PgSelectQueryBuilder<
 		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
 	}
 
+	/** @internal */
+	getSetOperatorConfig() {
+		return {
+			session: this.session,
+			dialect: this.dialect,
+			joinsNotNullableMap: this.joinsNotNullableMap,
+			fields: this.config.fields,
+		};
+	}
+
 	private createJoin<TJoinType extends JoinType>(
 		joinType: TJoinType,
 	): JoinFn<THKT, TTableName, TSelectMode, TJoinType, TSelection, TNullabilityMap> {
@@ -314,6 +325,114 @@ export abstract class PgSelectQueryBuilder<
 		return this;
 	}
 
+	union<
+		THKT extends PgSelectHKTBase,
+		TTableName extends string | undefined,
+		TSelection extends ColumnsSelection,
+		TSelectMode extends SelectMode,
+	>(
+		rightSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	): PgSetOperator<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode
+	> {
+		return new PgSetOperator('union', false, this as any, rightSelect);
+	}
+
+	unionAll<
+		THKT extends PgSelectHKTBase,
+		TTableName extends string | undefined,
+		TSelection extends ColumnsSelection,
+		TSelectMode extends SelectMode,
+	>(
+		rightSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	): PgSetOperator<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode
+	> {
+		return new PgSetOperator('union', true, this as any, rightSelect);
+	}
+
+	intersect<
+		THKT extends PgSelectHKTBase,
+		TTableName extends string | undefined,
+		TSelection extends ColumnsSelection,
+		TSelectMode extends SelectMode,
+	>(
+		rightSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	): PgSetOperator<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode
+	> {
+		return new PgSetOperator('intersect', false, this as any, rightSelect);
+	}
+
+	intersectAll<
+		THKT extends PgSelectHKTBase,
+		TTableName extends string | undefined,
+		TSelection extends ColumnsSelection,
+		TSelectMode extends SelectMode,
+	>(
+		rightSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	): PgSetOperator<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode
+	> {
+		return new PgSetOperator('intersect', true, this as any, rightSelect);
+	}
+
+	except<
+		THKT extends PgSelectHKTBase,
+		TTableName extends string | undefined,
+		TSelection extends ColumnsSelection,
+		TSelectMode extends SelectMode,
+	>(
+		rightSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	): PgSetOperator<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode
+	> {
+		return new PgSetOperator('except', false, this as any, rightSelect);
+	}
+
+	exceptAll<
+		THKT extends PgSelectHKTBase,
+		TTableName extends string | undefined,
+		TSelection extends ColumnsSelection,
+		TSelectMode extends SelectMode,
+	>(
+		rightSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	): PgSetOperator<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode
+	> {
+		return new PgSetOperator('except', true, this as any, rightSelect);
+	}
+
 	/**
 	 * Sets the HAVING clause of this query, which often
 	 * used with GROUP BY and filters rows after they've been
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
new file mode 100644
index 000000000..667a11d85
--- /dev/null
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -0,0 +1,326 @@
+import { entityKind, is } from '~/entity.ts';
+import {
+	applyMixins,
+	orderSelectedFields,
+	type Placeholder,
+	type Query,
+	QueryPromise,
+	SelectionProxyHandler,
+	SQL,
+	sql,
+	type ValueOrArray,
+} from '~/index.ts';
+import type { PgSession, PreparedQuery, PreparedQueryConfig } from '~/pg-core/session.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import { tracer } from '~/tracing.ts';
+import { type ColumnsSelection } from '~/view.ts';
+import { PgColumn } from '../columns/common.ts';
+import type { PgDialect } from '../dialect.ts';
+import type { PgSelect, PgSelectQueryBuilder } from './select.ts';
+import type { PgSelectHKTBase, PgSelectQueryBuilderHKT } from './select.types.ts';
+
+type SetOperator = 'union' | 'intersect' | 'except';
+
+export interface PgSetOperator<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends
+	TypedQueryBuilder<
+		BuildSubquerySelection<TSelection, TNullabilityMap>,
+		SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+	>,
+	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+{}
+
+export class PgSetOperator<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends TypedQueryBuilder<
+	BuildSubquerySelection<TSelection, TNullabilityMap>,
+	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> {
+	static readonly [entityKind]: string = 'PgSetOperator';
+
+	private session: PgSession | undefined;
+	private dialect: PgDialect;
+	private config: {
+		fields: Record<string, unknown>;
+		joinsNotNullableMap: Record<string, boolean>;
+		limit?: number | Placeholder;
+		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+	};
+
+	constructor(
+		private operator: SetOperator,
+		private isAll: boolean,
+		private leftSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+		private rightSelect:
+			| PgSelect<TTableName, TSelection, TSelectMode>
+			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	) {
+		super();
+
+		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
+		this.session = session;
+		this.dialect = dialect;
+		this.config = {
+			fields,
+			joinsNotNullableMap,
+		};
+	}
+
+	orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
+	orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+	orderBy(
+		...columns:
+			| [(aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>]
+			| (PgColumn | SQL | SQL.Aliased)[]
+	) {
+		if (typeof columns[0] === 'function') {
+			const orderBy = columns[0](
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+		} else {
+			this.config.orderBy = columns as (PgColumn | SQL | SQL.Aliased)[];
+		}
+		return this;
+	}
+
+	limit(limit: number) {
+		this.config.limit = limit;
+		return this;
+	}
+
+	toSQL(): Query {
+		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+		return rest;
+	}
+
+	override getSQL(): SQL<unknown> {
+		const leftChunk = sql`(${this.leftSelect.getSQL()}) `;
+		const rightChunk = sql`(${this.rightSelect.getSQL()})`;
+
+		let orderBySql;
+		if (this.config.orderBy && this.config.orderBy.length > 0) {
+			const orderByValues: SQL<unknown>[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const orderBy of this.config.orderBy) {
+				if (is(orderBy, PgColumn)) {
+					orderByValues.push(sql.raw(orderBy.name));
+				} else if (is(orderBy, SQL)) {
+					for (let i = 0; i < orderBy.queryChunks.length; i++) {
+						const chunk = orderBy.queryChunks[i];
+
+						if (is(chunk, PgColumn)) {
+							orderBy.queryChunks[i] = sql.raw(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${orderBy}`);
+				} else {
+					orderByValues.push(sql`${orderBy}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
+		}
+
+		const limitSql = this.config.limit ? sql` limit ${this.config.limit}` : undefined;
+
+		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}`;
+	}
+
+	private _prepare(name?: string): PreparedQuery<
+		PreparedQueryConfig & {
+			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+		}
+	> {
+		const { session, config: { fields, joinsNotNullableMap }, dialect } = this;
+		if (!session) {
+			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
+		}
+		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+			const fieldsList = orderSelectedFields<PgColumn>(fields);
+			const query = session.prepareQuery<
+				PreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] }
+			>(dialect.sqlToQuery(this.getSQL()), fieldsList, name);
+			query.joinsNotNullableMap = joinsNotNullableMap;
+			return query;
+		});
+	}
+
+	/**
+	 * Create a prepared statement for this query. This allows
+	 * the database to remember this query for the given session
+	 * and call it by name, rather than specifying the full query.
+	 *
+	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html|Postgres prepare documentation}
+	 */
+	prepare(name: string): PreparedQuery<
+		PreparedQueryConfig & {
+			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+		}
+	> {
+		return this._prepare(name);
+	}
+
+	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
+		return tracer.startActiveSpan('drizzle.operation', () => {
+			return this._prepare().execute(placeholderValues);
+		});
+	};
+}
+
+applyMixins(PgSetOperator, [QueryPromise]);
+
+export function union<
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+>(
+	leftSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	rightSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+): PgSetOperator<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode
+> {
+	return new PgSetOperator('union', false, leftSelect, rightSelect);
+}
+
+export function unionAll<
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+>(
+	leftSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	rightSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+): PgSetOperator<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode
+> {
+	return new PgSetOperator('union', true, leftSelect, rightSelect);
+}
+
+export function intersect<
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+>(
+	leftSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	rightSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+): PgSetOperator<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode
+> {
+	return new PgSetOperator('intersect', false, leftSelect, rightSelect);
+}
+
+export function intersectAll<
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+>(
+	leftSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	rightSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+): PgSetOperator<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode
+> {
+	return new PgSetOperator('intersect', true, leftSelect, rightSelect);
+}
+
+export function except<
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+>(
+	leftSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	rightSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+): PgSetOperator<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode
+> {
+	return new PgSetOperator('except', false, leftSelect, rightSelect);
+}
+
+export function exceptAll<
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+>(
+	leftSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+	rightSelect:
+		| PgSelect<TTableName, TSelection, TSelectMode>
+		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+): PgSetOperator<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode
+> {
+	return new PgSetOperator('except', true, leftSelect, rightSelect);
+}

From 943945a1685ab8964a106cb34bbb4737bcfec1ea Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Thu, 14 Sep 2023 00:04:41 -0400
Subject: [PATCH 07/72] Progress on type for only union in Mysql. More work
 needed

---
 .../query-builders/set-operators.ts           | 64 +++++++++++++------
 1 file changed, 43 insertions(+), 21 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 317ff0651..3024adbc3 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -1,6 +1,7 @@
 import { entityKind, is } from '~/entity.ts';
 import {
 	applyMixins,
+	type KnownKeysOnly,
 	orderSelectedFields,
 	type Placeholder,
 	type Query,
@@ -77,24 +78,40 @@ export abstract class MySqlSetOperatorBuilder<
 			fields: this.config.fields,
 		};
 	}
-
-	union(
-		rightSelect: MySqlSetOperatorBuilder<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap
-		>,
+	union<TValue extends TypedQueryBuilder<any, any>>(
+		rightSelect: TValue extends TypedQueryBuilder<any, infer R>
+			? R extends SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+				? KnownKeysOnly<R[number], SelectResult<TSelection, TSelectMode, TNullabilityMap>> extends R[number]
+					? TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+				: never
+			: never
+			: never,
 	): MySqlSetOperator<
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT
+		TPreparedQueryHKT,
+		TNullabilityMap
 	> {
-		return new MySqlSetOperator('union', false, this, rightSelect) as any;
+		return new MySqlSetOperator('union', false, this, rightSelect as any);
 	}
 
+	// union<TValue extends TypedQueryBuilder<any, any>>(
+	// 	rightSelect: TValue extends TypedQueryBuilder<any, infer R>
+	// 		? R extends SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+	// 			? TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	// 		: 'first'
+	// 		: 'second',
+	// ): MySqlSetOperator<
+	// 	TTableName,
+	// 	TSelection,
+	// 	TSelectMode,
+	// 	TPreparedQueryHKT,
+	// 	TNullabilityMap
+	// > {
+	// 	return new MySqlSetOperator('union', false, this, rightSelect as any);
+	// }
+
 	unionAll(
 		rightSelect: MySqlSetOperatorBuilder<
 			TTableName,
@@ -107,9 +124,10 @@ export abstract class MySqlSetOperatorBuilder<
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT
+		TPreparedQueryHKT,
+		TNullabilityMap
 	> {
-		return new MySqlSetOperator('union', true, this, rightSelect) as any;
+		return new MySqlSetOperator('union', true, this, rightSelect);
 	}
 
 	intersect(
@@ -124,9 +142,10 @@ export abstract class MySqlSetOperatorBuilder<
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT
+		TPreparedQueryHKT,
+		TNullabilityMap
 	> {
-		return new MySqlSetOperator('intersect', false, this, rightSelect) as any;
+		return new MySqlSetOperator('intersect', false, this, rightSelect);
 	}
 
 	intersectAll(
@@ -141,9 +160,10 @@ export abstract class MySqlSetOperatorBuilder<
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT
+		TPreparedQueryHKT,
+		TNullabilityMap
 	> {
-		return new MySqlSetOperator('intersect', true, this, rightSelect) as any;
+		return new MySqlSetOperator('intersect', true, this, rightSelect);
 	}
 
 	except(
@@ -158,9 +178,10 @@ export abstract class MySqlSetOperatorBuilder<
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT
+		TPreparedQueryHKT,
+		TNullabilityMap
 	> {
-		return new MySqlSetOperator('except', false, this, rightSelect) as any;
+		return new MySqlSetOperator('except', false, this, rightSelect);
 	}
 
 	exceptAll(
@@ -175,9 +196,10 @@ export abstract class MySqlSetOperatorBuilder<
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TPreparedQueryHKT
+		TPreparedQueryHKT,
+		TNullabilityMap
 	> {
-		return new MySqlSetOperator('except', true, this, rightSelect) as any;
+		return new MySqlSetOperator('except', true, this, rightSelect);
 	}
 
 	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): this;

From 06ed8de15251f0cbe0e7902f477961deaed4238e Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Thu, 14 Sep 2023 23:14:02 -0400
Subject: [PATCH 08/72] Added generic types to mysql Set Operation to generate
 type errors if the user attempts to select different types on both sides of
 the set operator

---
 .../query-builders/set-operators.ts           | 281 +++++++-----------
 drizzle-orm/src/utils.ts                      |   6 +
 2 files changed, 118 insertions(+), 169 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 3024adbc3..450d8e3c0 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -1,7 +1,6 @@
 import { entityKind, is } from '~/entity.ts';
 import {
 	applyMixins,
-	type KnownKeysOnly,
 	orderSelectedFields,
 	type Placeholder,
 	type Query,
@@ -9,6 +8,7 @@ import {
 	SelectionProxyHandler,
 	SQL,
 	sql,
+	type ValidateShape,
 	type ValueOrArray,
 } from '~/index.ts';
 import type {
@@ -29,6 +29,7 @@ import { MySqlColumn } from '../columns/common.ts';
 import type { MySqlDialect } from '../dialect.ts';
 
 type SetOperator = 'union' | 'intersect' | 'except';
+// type NewValidate<T, P, TResult = T> = T extends P ? P extends T ? TResult : 'one' : 'dos';
 
 export interface MySqlSetOperatorBuilder<
 	TTableName extends string | undefined,
@@ -78,127 +79,75 @@ export abstract class MySqlSetOperatorBuilder<
 			fields: this.config.fields,
 		};
 	}
-	union<TValue extends TypedQueryBuilder<any, any>>(
-		rightSelect: TValue extends TypedQueryBuilder<any, infer R>
-			? R extends SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-				? KnownKeysOnly<R[number], SelectResult<TSelection, TSelectMode, TNullabilityMap>> extends R[number]
-					? TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
-				: never
-			: never
-			: never,
-	): MySqlSetOperator<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	> {
-		return new MySqlSetOperator('union', false, this, rightSelect as any);
+	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect: TValue extends
+			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+				SelectResult<TSel, TMode, TNull>,
+				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+			>
+			: TValue,
+	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+		return new MySqlSetOperator('union', false, this, rightSelect);
 	}
 
-	// union<TValue extends TypedQueryBuilder<any, any>>(
-	// 	rightSelect: TValue extends TypedQueryBuilder<any, infer R>
-	// 		? R extends SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-	// 			? TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
-	// 		: 'first'
-	// 		: 'second',
-	// ): MySqlSetOperator<
-	// 	TTableName,
-	// 	TSelection,
-	// 	TSelectMode,
-	// 	TPreparedQueryHKT,
-	// 	TNullabilityMap
-	// > {
-	// 	return new MySqlSetOperator('union', false, this, rightSelect as any);
-	// }
-
-	unionAll(
-		rightSelect: MySqlSetOperatorBuilder<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap
-		>,
-	): MySqlSetOperator<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	> {
+	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect: TValue extends
+			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+				SelectResult<TSel, TMode, TNull>,
+				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+			>
+			: TValue,
+	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('union', true, this, rightSelect);
 	}
 
-	intersect(
-		rightSelect: MySqlSetOperatorBuilder<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap
-		>,
-	): MySqlSetOperator<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	> {
+	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect: TValue extends
+			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+				SelectResult<TSel, TMode, TNull>,
+				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+			>
+			: TValue,
+	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('intersect', false, this, rightSelect);
 	}
 
-	intersectAll(
-		rightSelect: MySqlSetOperatorBuilder<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap
-		>,
-	): MySqlSetOperator<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	> {
+	intersectAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect: TValue extends
+			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+				SelectResult<TSel, TMode, TNull>,
+				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+			>
+			: TValue,
+	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('intersect', true, this, rightSelect);
 	}
 
-	except(
-		rightSelect: MySqlSetOperatorBuilder<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap
-		>,
-	): MySqlSetOperator<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	> {
+	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect: TValue extends
+			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+				SelectResult<TSel, TMode, TNull>,
+				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+			>
+			: TValue,
+	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('except', false, this, rightSelect);
 	}
 
-	exceptAll(
-		rightSelect: MySqlSetOperatorBuilder<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap
-		>,
-	): MySqlSetOperator<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	> {
+	exceptAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect: TValue extends
+			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+				SelectResult<TSel, TMode, TNull>,
+				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+			>
+			: TValue,
+	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('except', true, this, rightSelect);
 	}
 
@@ -244,13 +193,7 @@ export class MySqlSetOperator<
 			TPreparedQueryHKT,
 			TNullabilityMap
 		>,
-		private rightSelect: MySqlSetOperatorBuilder<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap
-		>,
+		private rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
 		super();
 		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
@@ -370,8 +313,8 @@ export function union<
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<
 		TTableName,
@@ -380,13 +323,13 @@ export function union<
 		TPreparedQueryHKT,
 		TNullabilityMap
 	>,
-	rightSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
+	rightSelect: TValue extends
+		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+			SelectResult<TSel, TMode, TNull>,
+			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+		>
+		: TValue,
 ): MySqlSetOperator<
 	TTableName,
 	TSelection,
@@ -402,8 +345,8 @@ export function unionAll<
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<
 		TTableName,
@@ -412,13 +355,13 @@ export function unionAll<
 		TPreparedQueryHKT,
 		TNullabilityMap
 	>,
-	rightSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
+	rightSelect: TValue extends
+		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+			SelectResult<TSel, TMode, TNull>,
+			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+		>
+		: TValue,
 ): MySqlSetOperator<
 	TTableName,
 	TSelection,
@@ -434,8 +377,8 @@ export function intersect<
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<
 		TTableName,
@@ -444,13 +387,13 @@ export function intersect<
 		TPreparedQueryHKT,
 		TNullabilityMap
 	>,
-	rightSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
+	rightSelect: TValue extends
+		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+			SelectResult<TSel, TMode, TNull>,
+			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+		>
+		: TValue,
 ): MySqlSetOperator<
 	TTableName,
 	TSelection,
@@ -466,8 +409,8 @@ export function intersectAll<
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<
 		TTableName,
@@ -476,13 +419,13 @@ export function intersectAll<
 		TPreparedQueryHKT,
 		TNullabilityMap
 	>,
-	rightSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
+	rightSelect: TValue extends
+		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+			SelectResult<TSel, TMode, TNull>,
+			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+		>
+		: TValue,
 ): MySqlSetOperator<
 	TTableName,
 	TSelection,
@@ -498,8 +441,8 @@ export function except<
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<
 		TTableName,
@@ -508,13 +451,13 @@ export function except<
 		TPreparedQueryHKT,
 		TNullabilityMap
 	>,
-	rightSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
+	rightSelect: TValue extends
+		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+			SelectResult<TSel, TMode, TNull>,
+			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+		>
+		: TValue,
 ): MySqlSetOperator<
 	TTableName,
 	TSelection,
@@ -530,8 +473,8 @@ export function exceptAll<
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<
 		TTableName,
@@ -540,13 +483,13 @@ export function exceptAll<
 		TPreparedQueryHKT,
 		TNullabilityMap
 	>,
-	rightSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
+	rightSelect: TValue extends
+		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
+			SelectResult<TSel, TMode, TNull>,
+			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
+		>
+		: TValue,
 ): MySqlSetOperator<
 	TTableName,
 	TSelection,
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index dc71112eb..16c92cfc1 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -194,6 +194,12 @@ export interface DrizzleConfig<TSchema extends Record<string, unknown> = Record<
 	schema?: TSchema;
 }
 
+export type ValidateShape<T, ValidShape, TResult = T> = T extends ValidShape
+	? Exclude<keyof T, keyof ValidShape> extends never ? TResult
+	: Exclude<keyof T, keyof ValidShape> extends string ? `Invalid key(s): ${Exclude<keyof T, keyof ValidShape>}`
+	: 'uno'
+	: 'dos';
+
 export type KnownKeysOnly<T, U> = {
 	[K in keyof T]: K extends keyof U ? T[K] : never;
 };

From 1e75160c0091f71bb3ba7865a64b2ca23ca157d7 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Fri, 15 Sep 2023 17:01:15 +0300
Subject: [PATCH 09/72] Add Postgres replicas

---
 drizzle-orm/src/pg-core/db.ts                 |  50 ++
 integration-tests/tests/pg.test.ts            |  26 +-
 .../tests/replicas/postgres.test.ts           | 638 ++++++++++++++++++
 integration-tests/vitest.config.ts            |   2 +-
 4 files changed, 702 insertions(+), 14 deletions(-)
 create mode 100644 integration-tests/tests/replicas/postgres.test.ts

diff --git a/drizzle-orm/src/pg-core/db.ts b/drizzle-orm/src/pg-core/db.ts
index 4ac6575ed..86adad220 100644
--- a/drizzle-orm/src/pg-core/db.ts
+++ b/drizzle-orm/src/pg-core/db.ts
@@ -177,3 +177,53 @@ export class PgDatabase<
 		return this.session.transaction(transaction, config);
 	}
 }
+
+export type PgWithReplicas<Q> = Q & { $primary: Q };
+
+export const withReplicas = <
+	HKT extends QueryResultHKT,
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends TablesRelationalConfig,
+	Q extends PgDatabase<HKT, TFullSchema, TSchema>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): PgWithReplicas<Q> => {
+	const select: Q['select'] = (...args: any) => getReplica(replicas).select(args);
+	const selectDistinct: Q['selectDistinct'] = (...args: any) => getReplica(replicas).selectDistinct(args);
+	const selectDistinctOn: Q['selectDistinctOn'] = (...args: any) => getReplica(replicas).selectDistinctOn(args);
+	const $with: Q['with'] = (...args: any) => getReplica(replicas).with(args);
+
+	const update: Q['update'] = (...args: any) => primary.update(args);
+	const insert: Q['insert'] = (...args: any) => primary.insert(args);
+	const $delete: Q['delete'] = (...args: any) => primary.delete(args);
+	const execute: Q['execute'] = (...args: any) => primary.execute(args);
+	const transaction: Q['transaction'] = (...args: any) => primary.transaction(args);
+	const refreshMaterializedView: Q['refreshMaterializedView'] = (...args: any) => primary.refreshMaterializedView(args);
+
+	return new Proxy<Q & { $primary: Q }>(
+		{
+			...primary,
+			update,
+			insert,
+			delete: $delete,
+			execute,
+			transaction,
+			refreshMaterializedView,
+			$primary: primary,
+			select,
+			selectDistinct,
+			selectDistinctOn,
+			with: $with,
+		},
+		{
+			get(target, prop, _receiver) {
+				if (prop === 'query') {
+					return getReplica(replicas).query;
+				}
+				return target[prop as keyof typeof target];
+			},
+		},
+	);
+};
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index fb2f058f6..5f16a5b7b 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -5,6 +5,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	eq,
 	gt,
@@ -17,9 +20,6 @@ import {
 	sql,
 	type SQLWrapper,
 	TransactionRollbackError,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
 import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
@@ -37,7 +37,6 @@ import {
 	macaddr,
 	macaddr8,
 	type PgColumn,
-	pgEnum,
 	pgMaterializedView,
 	pgTable,
 	pgTableCreator,
@@ -49,6 +48,7 @@ import {
 	uniqueKeyName,
 	uuid as pgUuid,
 	varchar,
+	pgEnum,
 } from 'drizzle-orm/pg-core';
 import getPort from 'get-port';
 import pg from 'pg';
@@ -2465,7 +2465,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2475,17 +2475,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2497,11 +2497,11 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });
diff --git a/integration-tests/tests/replicas/postgres.test.ts b/integration-tests/tests/replicas/postgres.test.ts
new file mode 100644
index 000000000..28fee49ba
--- /dev/null
+++ b/integration-tests/tests/replicas/postgres.test.ts
@@ -0,0 +1,638 @@
+import { sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { withReplicas } from 'drizzle-orm/pg-core';
+import { describe, expect, it, vi } from 'vitest';
+
+describe('[select] read replicas postgres', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		db.$primary.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.select().from({} as any);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[selectDistinct] read replicas postgres', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		db.$primary.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.selectDistinct().from({} as any);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[selectDistinctOn] read replicas postgres', () => {
+	it('primary selectDistinctOn', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinctOn');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinctOn');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinctOn');
+
+		db.$primary.selectDistinctOn({} as any).from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica selectDistinctOn', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinctOn');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinctOn');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinctOn');
+
+		db.selectDistinctOn({} as any).from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.selectDistinctOn({} as any).from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica selectDistinctOn', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinctOn');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinctOn');
+
+		db.selectDistinctOn({} as any).from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.selectDistinctOn({} as any).from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica selectDistinctOn + primary selectDistinctOn', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinctOn');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinctOn');
+
+		db.selectDistinctOn({} as any).from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.selectDistinctOn({} as any).from({} as any);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read selectDistinctOn', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinctOn');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinctOn');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinctOn');
+
+		db.selectDistinctOn({} as any).from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.selectDistinctOn({} as any).from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[with] read replicas postgres', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.$primary.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[update] replicas postgres', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
+
+		db.update({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.update({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$primary.update({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[delete] replicas postgres', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
+
+		db.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$primary.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[insert] replicas postgres', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
+
+		db.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$primary.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[execute] replicas postgres', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'execute');
+		const spyRead1 = vi.spyOn(read1, 'execute');
+		const spyRead2 = vi.spyOn(read2, 'execute');
+
+		// expect(db.execute(sql``)).rejects.toThrow();
+
+		try {
+			db.execute(sql``);
+		} catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		try {
+			db.execute(sql``);
+		} catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		try {
+			db.execute(sql``);
+		} catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[transaction] replicas postgres', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[refreshView] replicas postgres', () => {
+	it('primary refreshView', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'refreshMaterializedView');
+		const spyRead1 = vi.spyOn(read1, 'refreshMaterializedView');
+		const spyRead2 = vi.spyOn(read2, 'refreshMaterializedView');
+
+		db.refreshMaterializedView({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.refreshMaterializedView({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$primary.refreshMaterializedView({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
diff --git a/integration-tests/vitest.config.ts b/integration-tests/vitest.config.ts
index 9a0089280..35b0c9b76 100644
--- a/integration-tests/vitest.config.ts
+++ b/integration-tests/vitest.config.ts
@@ -4,7 +4,7 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
 	test: {
-		include: ['tests/relational/**/*.test.ts', 'tests/libsql-batch.test.ts', 'tests/d1-batch.test.ts'],
+		include: ['tests/relational/**/*.test.ts', 'tests/libsql-batch.test.ts', 'tests/d1-batch.test.ts', 'tests/replicas/**/*'],
 		exclude: [
 			...(process.env.SKIP_PLANETSCALE_TESTS ? ['tests/relational/mysql.planetscale.test.ts'] : []),
 			'tests/relational/vercel.test.ts',

From 273a88429bafce29850b8322b7c6d342ac4f56fa Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Fri, 15 Sep 2023 23:56:40 -0400
Subject: [PATCH 10/72] Added support to pass multiple arguments to the
 standalone set operator functions. The types might need some more work

---
 .../query-builders/set-operators.ts           | 277 +++++++-----------
 1 file changed, 102 insertions(+), 175 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 450d8e3c0..688225c22 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -29,7 +29,18 @@ import { MySqlColumn } from '../columns/common.ts';
 import type { MySqlDialect } from '../dialect.ts';
 
 type SetOperator = 'union' | 'intersect' | 'except';
-// type NewValidate<T, P, TResult = T> = T extends P ? P extends T ? TResult : 'one' : 'dos';
+
+type SetOperatorRightSelect<
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+> = TValue extends MySqlSetOperatorBuilder<any, infer TSel, infer TMode, any, infer TNull> ? ValidateShape<
+		SelectResult<TSel, TMode, TNull>,
+		SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+		TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	>
+	: TValue;
 
 export interface MySqlSetOperatorBuilder<
 	TTableName extends string | undefined,
@@ -80,73 +91,37 @@ export abstract class MySqlSetOperatorBuilder<
 		};
 	}
 	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: TValue extends
-			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-				SelectResult<TSel, TMode, TNull>,
-				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-			>
-			: TValue,
+		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('union', false, this, rightSelect);
 	}
 
 	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: TValue extends
-			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-				SelectResult<TSel, TMode, TNull>,
-				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-			>
-			: TValue,
+		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('union', true, this, rightSelect);
 	}
 
 	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: TValue extends
-			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-				SelectResult<TSel, TMode, TNull>,
-				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-			>
-			: TValue,
+		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('intersect', false, this, rightSelect);
 	}
 
 	intersectAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: TValue extends
-			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-				SelectResult<TSel, TMode, TNull>,
-				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-			>
-			: TValue,
+		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('intersect', true, this, rightSelect);
 	}
 
 	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: TValue extends
-			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-				SelectResult<TSel, TMode, TNull>,
-				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-			>
-			: TValue,
+		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('except', false, this, rightSelect);
 	}
 
 	exceptAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: TValue extends
-			MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-				SelectResult<TSel, TMode, TNull>,
-				SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-				MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-			>
-			: TValue,
+		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 		return new MySqlSetOperator('except', true, this, rightSelect);
 	}
@@ -316,28 +291,20 @@ export function union<
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
-	leftSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
-	rightSelect: TValue extends
-		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-			SelectResult<TSel, TMode, TNull>,
-			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-		>
-		: TValue,
-): MySqlSetOperator<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap
-> {
-	return new MySqlSetOperator('union', false, leftSelect, rightSelect);
+	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
+	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	if (rightSelects.length < 1) {
+		throw new Error('This operator requires at least two arguments');
+	}
+
+	const [rightSelect, ...rest] = rightSelects;
+
+	if (rightSelect && rest.length === 0) {
+		return new MySqlSetOperator('union', false, leftSelect, rightSelect);
+	}
+
+	return union(new MySqlSetOperator('union', false, leftSelect, rightSelect!), ...rest);
 }
 
 export function unionAll<
@@ -348,28 +315,20 @@ export function unionAll<
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
-	leftSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
-	rightSelect: TValue extends
-		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-			SelectResult<TSel, TMode, TNull>,
-			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-		>
-		: TValue,
-): MySqlSetOperator<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap
-> {
-	return new MySqlSetOperator('union', true, leftSelect, rightSelect);
+	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
+	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	if (rightSelects.length < 1) {
+		throw new Error('This operator requires at least two arguments');
+	}
+
+	const [rightSelect, ...rest] = rightSelects;
+
+	if (rightSelect && rest.length === 0) {
+		return new MySqlSetOperator('union', true, leftSelect, rightSelect);
+	}
+
+	return unionAll(new MySqlSetOperator('union', true, leftSelect, rightSelect!), ...rest);
 }
 
 export function intersect<
@@ -380,28 +339,20 @@ export function intersect<
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
-	leftSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
-	rightSelect: TValue extends
-		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-			SelectResult<TSel, TMode, TNull>,
-			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-		>
-		: TValue,
-): MySqlSetOperator<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap
-> {
-	return new MySqlSetOperator('intersect', false, leftSelect, rightSelect);
+	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
+	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	if (rightSelects.length < 1) {
+		throw new Error('This operator requires at least two arguments');
+	}
+
+	const [rightSelect, ...rest] = rightSelects;
+
+	if (rightSelect && rest.length === 0) {
+		return new MySqlSetOperator('intersect', false, leftSelect, rightSelect);
+	}
+
+	return intersect(new MySqlSetOperator('intersect', false, leftSelect, rightSelect!), ...rest);
 }
 
 export function intersectAll<
@@ -412,28 +363,20 @@ export function intersectAll<
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
-	leftSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
-	rightSelect: TValue extends
-		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-			SelectResult<TSel, TMode, TNull>,
-			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-		>
-		: TValue,
-): MySqlSetOperator<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap
-> {
-	return new MySqlSetOperator('intersect', true, leftSelect, rightSelect);
+	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
+	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	if (rightSelects.length < 1) {
+		throw new Error('This operator requires at least two arguments');
+	}
+
+	const [rightSelect, ...rest] = rightSelects;
+
+	if (rightSelect && rest.length === 0) {
+		return new MySqlSetOperator('intersect', true, leftSelect, rightSelect);
+	}
+
+	return intersectAll(new MySqlSetOperator('intersect', true, leftSelect, rightSelect!), ...rest);
 }
 
 export function except<
@@ -444,28 +387,20 @@ export function except<
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
-	leftSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
-	rightSelect: TValue extends
-		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-			SelectResult<TSel, TMode, TNull>,
-			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-		>
-		: TValue,
-): MySqlSetOperator<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap
-> {
-	return new MySqlSetOperator('except', false, leftSelect, rightSelect);
+	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
+	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	if (rightSelects.length < 1) {
+		throw new Error('This operator requires at least two arguments');
+	}
+
+	const [rightSelect, ...rest] = rightSelects;
+
+	if (rightSelect && rest.length === 0) {
+		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
+	}
+
+	return except(new MySqlSetOperator('except', false, leftSelect, rightSelect!), ...rest);
 }
 
 export function exceptAll<
@@ -476,26 +411,18 @@ export function exceptAll<
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
-	leftSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap
-	>,
-	rightSelect: TValue extends
-		MySqlSetOperatorBuilder<infer TName, infer TSel, infer TMode, infer TPrepared, infer TNull> ? ValidateShape<
-			SelectResult<TSel, TMode, TNull>,
-			SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-			MySqlSetOperatorBuilder<TName, TSel, TMode, TPrepared, TNull>
-		>
-		: TValue,
-): MySqlSetOperator<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap
-> {
-	return new MySqlSetOperator('except', true, leftSelect, rightSelect);
+	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
+	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	if (rightSelects.length < 1) {
+		throw new Error('This operator requires at least two arguments');
+	}
+
+	const [rightSelect, ...rest] = rightSelects;
+
+	if (rightSelect && rest.length === 0) {
+		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
+	}
+
+	return exceptAll(new MySqlSetOperator('except', false, leftSelect, rightSelect!), ...rest);
 }

From 4c2f929418c80516efc1751a3a824e4dd7cd76a3 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sun, 17 Sep 2023 01:06:13 -0400
Subject: [PATCH 11/72] Added function support to the set operators methods in
 mysql

---
 .../query-builders/set-operators.ts           | 61 +++++++++++++++----
 1 file changed, 49 insertions(+), 12 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 688225c22..af0b37152 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -30,6 +30,19 @@ import type { MySqlDialect } from '../dialect.ts';
 
 type SetOperator = 'union' | 'intersect' | 'except';
 
+const getMySqlSetOperators = () => {
+	return {
+		union,
+		unionAll,
+		intersect,
+		intersectAll,
+		except,
+		exceptAll,
+	};
+};
+
+type MySqlSetOperators = ReturnType<typeof getMySqlSetOperators>;
+
 type SetOperatorRightSelect<
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	TSelection extends ColumnsSelection,
@@ -91,39 +104,63 @@ export abstract class MySqlSetOperatorBuilder<
 		};
 	}
 	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		return new MySqlSetOperator('union', false, this, rightSelect);
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+
+		return new MySqlSetOperator('union', false, this, rightSelectOrig);
 	}
 
 	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		return new MySqlSetOperator('union', true, this, rightSelect);
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+
+		return new MySqlSetOperator('union', true, this, rightSelectOrig);
 	}
 
 	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		return new MySqlSetOperator('intersect', false, this, rightSelect);
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+
+		return new MySqlSetOperator('intersect', false, this, rightSelectOrig);
 	}
 
 	intersectAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		return new MySqlSetOperator('intersect', true, this, rightSelect);
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+
+		return new MySqlSetOperator('intersect', true, this, rightSelectOrig);
 	}
 
 	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		return new MySqlSetOperator('except', false, this, rightSelect);
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+
+		return new MySqlSetOperator('except', false, this, rightSelectOrig);
 	}
 
 	exceptAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
 	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		return new MySqlSetOperator('except', true, this, rightSelect);
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+
+		return new MySqlSetOperator('except', true, this, rightSelectOrig);
 	}
 
 	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): this;

From c842f4d9ac8092f6bb16af7512f1e8ff7b7ede1c Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sun, 17 Sep 2023 02:43:43 -0400
Subject: [PATCH 12/72] (Mysql) fixed set operator function accepting only one
 parameter

---
 .../query-builders/set-operators.ts           | 97 ++++++++-----------
 1 file changed, 43 insertions(+), 54 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index af0b37152..f0ff107bf 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -311,6 +311,7 @@ export class MySqlSetOperator<
 	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
 		const self = this;
 		return async function*(placeholderValues) {
+			console.log('placeholderValues', placeholderValues);
 			yield* self.prepare().iterator(placeholderValues);
 		};
 	};
@@ -329,19 +330,17 @@ export function union<
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (rightSelects.length < 1) {
-		throw new Error('This operator requires at least two arguments');
-	}
-
-	const [rightSelect, ...rest] = rightSelects;
-
-	if (rightSelect && rest.length === 0) {
+	if (restSelects.length === 0) {
 		return new MySqlSetOperator('union', false, leftSelect, rightSelect);
 	}
 
-	return union(new MySqlSetOperator('union', false, leftSelect, rightSelect!), ...rest);
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return union(new MySqlSetOperator('union', false, leftSelect, rightSelect), select, ...rest);
 }
 
 export function unionAll<
@@ -353,19 +352,17 @@ export function unionAll<
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (rightSelects.length < 1) {
-		throw new Error('This operator requires at least two arguments');
-	}
-
-	const [rightSelect, ...rest] = rightSelects;
-
-	if (rightSelect && rest.length === 0) {
+	if (restSelects.length === 0) {
 		return new MySqlSetOperator('union', true, leftSelect, rightSelect);
 	}
 
-	return unionAll(new MySqlSetOperator('union', true, leftSelect, rightSelect!), ...rest);
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return unionAll(new MySqlSetOperator('union', true, leftSelect, rightSelect), select, ...rest);
 }
 
 export function intersect<
@@ -377,19 +374,17 @@ export function intersect<
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (rightSelects.length < 1) {
-		throw new Error('This operator requires at least two arguments');
-	}
-
-	const [rightSelect, ...rest] = rightSelects;
-
-	if (rightSelect && rest.length === 0) {
+	if (restSelects.length === 0) {
 		return new MySqlSetOperator('intersect', false, leftSelect, rightSelect);
 	}
 
-	return intersect(new MySqlSetOperator('intersect', false, leftSelect, rightSelect!), ...rest);
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return intersect(new MySqlSetOperator('intersect', false, leftSelect, rightSelect!), select, ...rest);
 }
 
 export function intersectAll<
@@ -401,19 +396,17 @@ export function intersectAll<
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (rightSelects.length < 1) {
-		throw new Error('This operator requires at least two arguments');
-	}
-
-	const [rightSelect, ...rest] = rightSelects;
-
-	if (rightSelect && rest.length === 0) {
+	if (restSelects.length === 0) {
 		return new MySqlSetOperator('intersect', true, leftSelect, rightSelect);
 	}
 
-	return intersectAll(new MySqlSetOperator('intersect', true, leftSelect, rightSelect!), ...rest);
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return intersectAll(new MySqlSetOperator('intersect', true, leftSelect, rightSelect!), select, ...rest);
 }
 
 export function except<
@@ -425,19 +418,17 @@ export function except<
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (rightSelects.length < 1) {
-		throw new Error('This operator requires at least two arguments');
-	}
-
-	const [rightSelect, ...rest] = rightSelects;
-
-	if (rightSelect && rest.length === 0) {
+	if (restSelects.length === 0) {
 		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
 	}
 
-	return except(new MySqlSetOperator('except', false, leftSelect, rightSelect!), ...rest);
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return except(new MySqlSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
 }
 
 export function exceptAll<
@@ -449,17 +440,15 @@ export function exceptAll<
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	...rightSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (rightSelects.length < 1) {
-		throw new Error('This operator requires at least two arguments');
-	}
-
-	const [rightSelect, ...rest] = rightSelects;
-
-	if (rightSelect && rest.length === 0) {
+	if (restSelects.length === 0) {
 		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
 	}
 
-	return exceptAll(new MySqlSetOperator('except', false, leftSelect, rightSelect!), ...rest);
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return exceptAll(new MySqlSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
 }

From a21e3861bb7a53f55856c362b4725faff9647a80 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sun, 17 Sep 2023 02:44:07 -0400
Subject: [PATCH 13/72] (mysql) added type tests for the set operators

---
 drizzle-orm/type-tests/mysql/set-operators.ts | 172 ++++++++++++++++++
 1 file changed, 172 insertions(+)
 create mode 100644 drizzle-orm/type-tests/mysql/set-operators.ts

diff --git a/drizzle-orm/type-tests/mysql/set-operators.ts b/drizzle-orm/type-tests/mysql/set-operators.ts
new file mode 100644
index 000000000..4c95fa9fa
--- /dev/null
+++ b/drizzle-orm/type-tests/mysql/set-operators.ts
@@ -0,0 +1,172 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import { eq } from '~/expressions.ts';
+import { except, exceptAll, intersect, intersectAll, union, unionAll } from '~/mysql-core/index.ts';
+import { desc, sql } from '~/sql/index.ts';
+import { db } from './db.ts';
+import { cities, classes, newYorkers, users } from './tables.ts';
+
+const unionTest = await db
+	.select({ id: users.id })
+	.from(users)
+	.union(
+		db
+			.select({ id: users.id })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number }[], typeof unionTest>>;
+
+const unionAllTest = await db
+	.select({ id: users.id, text: users.text })
+	.from(users)
+	.unionAll(
+		db.select({ id: users.id, text: users.text })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; text: string | null }[], typeof unionAllTest>>;
+
+const intersectTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.intersect(({ intersect }) =>
+		intersect(
+			db
+				.select({ id: users.id, homeCity: users.homeCity })
+				.from(users),
+			db
+				.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+				.from(users),
+		)
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
+
+const intersectAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.intersectAll(
+		db
+			.select({ id: users.id, homeCity: users.class })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof intersectAllTest>>;
+
+const exceptTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
+
+const exceptAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.exceptAll(
+		db
+			.select({ id: users.id, homeCity: sql<'A' | 'C'>`${users.class}` })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof exceptAllTest>>;
+
+const union2Test = await union(db.select().from(cities), db.select().from(cities));
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof union2Test>>;
+
+const unionAll2Test = await unionAll(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select().from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof unionAll2Test>>;
+
+const intersect2Test = await intersect(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
+
+const intersectAll2Test = await intersectAll(
+	db.select({
+		id: cities.id,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+	})
+		.from(cities),
+).orderBy(desc(cities.id)).limit(23);
+
+Expect<Equal<{ id: number }[], typeof intersectAll2Test>>;
+
+const except2Test = await except(
+	db.select({
+		userId: newYorkers.userId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number }[], typeof except2Test>>;
+
+const exceptAll2Test = await exceptAll(
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
+
+{
+	const query = db
+		.select()
+		.from(users)
+		.union(
+			db.select()
+				.from(users),
+		)
+		.prepare()
+		.iterator();
+	for await (const row of query) {
+		Expect<Equal<typeof users.$inferSelect, typeof row>>();
+	}
+}
+
+// @ts-expect-error - The select on both sites must be the same shape
+db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
+
+// @ts-expect-error - The select on both sites must be the same shape
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes));

From 863efc4ead946d103b6b4bab802a3fd31cc6c10a Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Mon, 18 Sep 2023 16:11:14 +0300
Subject: [PATCH 14/72] Add mysql and sqlite withReplicas + tests

---
 drizzle-orm/src/mysql-core/db.ts              |  47 ++
 drizzle-orm/src/sqlite-core/db.ts             |  63 +-
 .../tests/replicas/mysql.test.ts              | 719 ++++++++++++++++++
 .../tests/replicas/postgres.test.ts           | 224 +++++-
 .../tests/replicas/sqlite.test.ts             | 719 ++++++++++++++++++
 5 files changed, 1769 insertions(+), 3 deletions(-)
 create mode 100644 integration-tests/tests/replicas/mysql.test.ts
 create mode 100644 integration-tests/tests/replicas/sqlite.test.ts

diff --git a/drizzle-orm/src/mysql-core/db.ts b/drizzle-orm/src/mysql-core/db.ts
index 3c79f9d86..036f2a36f 100644
--- a/drizzle-orm/src/mysql-core/db.ts
+++ b/drizzle-orm/src/mysql-core/db.ts
@@ -179,3 +179,50 @@ export class MySqlDatabase<
 		return this.session.transaction(transaction, config);
 	}
 }
+
+export type MySQLWithReplicas<Q> = Q & { $primary: Q };
+
+export const withReplicas = <
+	HKT extends QueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends TablesRelationalConfig,
+	Q extends MySqlDatabase<HKT, TPreparedQueryHKT, TFullSchema, TSchema>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): MySQLWithReplicas<Q> => {
+	const select: Q['select'] = (...args: any) => getReplica(replicas).select(args);
+	const selectDistinct: Q['selectDistinct'] = (...args: any) => getReplica(replicas).selectDistinct(args);
+	const $with: Q['with'] = (...args: any) => getReplica(replicas).with(args);
+
+	const update: Q['update'] = (...args: any) => primary.update(args);
+	const insert: Q['insert'] = (...args: any) => primary.insert(args);
+	const $delete: Q['delete'] = (...args: any) => primary.delete(args);
+	const execute: Q['execute'] = (...args: any) => primary.execute(args);
+	const transaction: Q['transaction'] = (...args: any) => primary.transaction(args);
+
+	return new Proxy<Q & { $primary: Q }>(
+		{
+			...primary,
+			update,
+			insert,
+			delete: $delete,
+			execute,
+			transaction,
+			$primary: primary,
+			select,
+			selectDistinct,
+			with: $with,
+		},
+		{
+			get(target, prop, _receiver) {
+				if (prop === 'query') {
+					return getReplica(replicas).query;
+				}
+				return target[prop as keyof typeof target];
+			},
+		},
+	);
+};
diff --git a/drizzle-orm/src/sqlite-core/db.ts b/drizzle-orm/src/sqlite-core/db.ts
index 22276f100..350b27e62 100644
--- a/drizzle-orm/src/sqlite-core/db.ts
+++ b/drizzle-orm/src/sqlite-core/db.ts
@@ -14,15 +14,21 @@ import {
 	SQLiteSelectBuilder,
 	SQLiteUpdateBuilder,
 } from '~/sqlite-core/query-builders/index.ts';
-import type { DBResult, Result, SQLiteSession, SQLiteTransaction, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type {
+	DBResult,
+	Result,
+	SQLiteSession,
+	SQLiteTransaction,
+	SQLiteTransactionConfig,
+} from '~/sqlite-core/session.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
 import { type DrizzleTypeError } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { RelationalQueryBuilder } from './query-builders/query.ts';
+import { SQLiteRaw } from './query-builders/raw.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import type { WithSubqueryWithSelection } from './subquery.ts';
-import { SQLiteRaw } from './query-builders/raw.ts';
 
 export class BaseSQLiteDatabase<
 	TResultKind extends 'sync' | 'async',
@@ -195,3 +201,56 @@ export class BaseSQLiteDatabase<
 		return this.session.transaction(transaction, config);
 	}
 }
+
+export type SQLiteWithReplicas<Q> = Q & { $primary: Q };
+
+export const withReplicas = <
+	TResultKind extends 'sync' | 'async',
+	TRunResult,
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends TablesRelationalConfig,
+	Q extends BaseSQLiteDatabase<TResultKind, TRunResult, TFullSchema, TSchema>,
+>(
+	primary: Q,
+	replicas: [Q, ...Q[]],
+	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
+): SQLiteWithReplicas<Q> => {
+	const select: Q['select'] = (...args: any) => getReplica(replicas).select(args);
+	const selectDistinct: Q['selectDistinct'] = (...args: any) => getReplica(replicas).selectDistinct(args);
+	const $with: Q['with'] = (...args: any) => getReplica(replicas).with(args);
+
+	const update: Q['update'] = (...args: any) => primary.update(args);
+	const insert: Q['insert'] = (...args: any) => primary.insert(args);
+	const $delete: Q['delete'] = (...args: any) => primary.delete(args);
+	const run: Q['run'] = (...args: any) => primary.run(args);
+	const all: Q['all'] = (...args: any) => primary.all(args);
+	const get: Q['get'] = (...args: any) => primary.get(args);
+	const values: Q['values'] = (...args: any) => primary.values(args);
+	const transaction: Q['transaction'] = (...args: any) => primary.transaction(args);
+
+	return new Proxy<Q & { $primary: Q }>(
+		{
+			...primary,
+			update,
+			insert,
+			delete: $delete,
+			run,
+			all,
+			get,
+			values,
+			transaction,
+			$primary: primary,
+			select,
+			selectDistinct,
+			with: $with,
+		},
+		{
+			get(target, prop, _receiver) {
+				if (prop === 'query') {
+					return getReplica(replicas).query;
+				}
+				return target[prop as keyof typeof target];
+			},
+		},
+	);
+};
diff --git a/integration-tests/tests/replicas/mysql.test.ts b/integration-tests/tests/replicas/mysql.test.ts
new file mode 100644
index 000000000..62fa6af41
--- /dev/null
+++ b/integration-tests/tests/replicas/mysql.test.ts
@@ -0,0 +1,719 @@
+import { sql } from 'drizzle-orm';
+import { boolean, mysqlTable, serial, text, withReplicas } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { describe, expect, it, vi } from 'vitest';
+
+const usersTable = mysqlTable('users', {
+	id: serial('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+});
+
+describe('[select] read replicas postgres', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		db.$primary.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.select().from({} as any);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
+
+		db.select().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[selectDistinct] read replicas postgres', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		db.$primary.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.selectDistinct().from({} as any);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+		db.selectDistinct().from({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[with] read replicas postgres', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.$primary.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
+
+		db.with();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[update] replicas postgres', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
+
+		db.update({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.update({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$primary.update({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[delete] replicas postgres', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
+
+		db.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$primary.delete({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[insert] replicas postgres', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
+
+		db.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.$primary.insert({} as any);
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[execute] replicas postgres', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'execute');
+		const spyRead1 = vi.spyOn(read1, 'execute');
+		const spyRead2 = vi.spyOn(read2, 'execute');
+
+		// expect(db.execute(sql``)).rejects.toThrow();
+
+		try {
+			db.execute(sql``);
+		} catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		try {
+			db.execute(sql``);
+		} catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		try {
+			db.execute(sql``);
+		} catch { /* empty */ }
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[transaction] replicas postgres', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findFirst] read replicas postgres', () => {
+	it('primary findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read2 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.$primary.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read2 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findFirst + primary findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read2 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findMany] read replicas postgres', () => {
+	it('primary findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read2 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+		db.$primary.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read2 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findMany + primary findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findMany();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read1 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+		const read2 = drizzle({} as any, { schema: { usersTable }, mode: 'default' });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
\ No newline at end of file
diff --git a/integration-tests/tests/replicas/postgres.test.ts b/integration-tests/tests/replicas/postgres.test.ts
index 28fee49ba..a782045c4 100644
--- a/integration-tests/tests/replicas/postgres.test.ts
+++ b/integration-tests/tests/replicas/postgres.test.ts
@@ -1,8 +1,16 @@
 import { sql } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/node-postgres';
-import { withReplicas } from 'drizzle-orm/pg-core';
+import { boolean, jsonb, pgTable, serial, text, timestamp, withReplicas } from 'drizzle-orm/pg-core';
 import { describe, expect, it, vi } from 'vitest';
 
+const usersTable = pgTable('users', {
+	id: serial('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: jsonb('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
 describe('[select] read replicas postgres', () => {
 	it('primary select', () => {
 		const primaryDb = drizzle({} as any);
@@ -636,3 +644,217 @@ describe('[refreshView] replicas postgres', () => {
 		expect(spyRead2).toHaveBeenCalledTimes(0);
 	});
 });
+
+describe('[findFirst] read replicas postgres', () => {
+	it('primary findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.$primary.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
+		
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findFirst + primary findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.query.usersTable.findFirst();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
+
+describe('[findMany] read replicas postgres', () => {
+	it('primary findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+		db.$primary.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
+		
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
+
+	it('single read replica findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
+
+	it('single read replica findMany + primary findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		
+		const db = withReplicas(primaryDb, [read1]);
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+		db.$primary.query.usersTable.findMany();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
+
+	it('always first read findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
+
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+		db.query.usersTable.findMany();
+
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
diff --git a/integration-tests/tests/replicas/sqlite.test.ts b/integration-tests/tests/replicas/sqlite.test.ts
new file mode 100644
index 000000000..b55dce37c
--- /dev/null
+++ b/integration-tests/tests/replicas/sqlite.test.ts
@@ -0,0 +1,719 @@
+// import { sql } from 'drizzle-orm';
+// import { sqliteTable, int, text, withReplicas } from 'drizzle-orm/sqlite-core';
+// import { drizzle } from 'drizzle-orm/libsql';
+// import { describe, expect, it, vi } from 'vitest';
+
+// const usersTable = sqliteTable('users', {
+// 	id: int('id' as string).primaryKey(),
+// 	name: text('name').notNull(),
+// });
+
+// describe('[select] read replicas postgres', () => {
+// 	it('primary select', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
+// 		const spyRead1 = vi.spyOn(read1, 'select');
+// 		const spyRead2 = vi.spyOn(read2, 'select');
+
+// 		db.$primary.select().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+
+// 	it('random replica select', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], () => {
+// 			return randomMockReplica();
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
+// 		const spyRead1 = vi.spyOn(read1, 'select');
+// 		const spyRead2 = vi.spyOn(read2, 'select');
+
+// 		db.select().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.select().from({} as any);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('single read replica select', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
+// 		const spyRead1 = vi.spyOn(read1, 'select');
+
+// 		db.select().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.select().from({} as any);
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 	});
+
+// 	it('single read replica select + primary select', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
+// 		const spyRead1 = vi.spyOn(read1, 'select');
+
+// 		db.select().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.$primary.select().from({} as any);
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('always first read select', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+// 			return replicas[0]!;
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
+// 		const spyRead1 = vi.spyOn(read1, 'select');
+// 		const spyRead2 = vi.spyOn(read2, 'select');
+
+// 		db.select().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.select().from({} as any);
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[selectDistinct] read replicas postgres', () => {
+// 	it('primary selectDistinct', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+// 		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+// 		db.$primary.selectDistinct().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+
+// 	it('random replica selectDistinct', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], () => {
+// 			return randomMockReplica();
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+// 		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+// 		db.selectDistinct().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.selectDistinct().from({} as any);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('single read replica selectDistinct', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+// 		db.selectDistinct().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.selectDistinct().from({} as any);
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 	});
+
+// 	it('single read replica selectDistinct + primary selectDistinct', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+
+// 		db.selectDistinct().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.$primary.selectDistinct().from({} as any);
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('always first read selectDistinct', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+// 			return replicas[0]!;
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+// 		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+
+// 		db.selectDistinct().from({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.selectDistinct().from({} as any);
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[with] read replicas postgres', () => {
+// 	it('primary with', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
+// 		const spyRead1 = vi.spyOn(read1, 'with');
+// 		const spyRead2 = vi.spyOn(read2, 'with');
+
+// 		db.$primary.with();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+
+// 	it('random replica with', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], () => {
+// 			return randomMockReplica();
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
+// 		const spyRead1 = vi.spyOn(read1, 'with');
+// 		const spyRead2 = vi.spyOn(read2, 'with');
+
+// 		db.with();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.with();
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('single read replica with', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
+// 		const spyRead1 = vi.spyOn(read1, 'with');
+
+// 		db.with();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.with();
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 	});
+
+// 	it('single read replica with + primary with', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
+// 		const spyRead1 = vi.spyOn(read1, 'with');
+
+// 		db.with();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.$primary.with();
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('always first read with', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+// 			return replicas[0]!;
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
+// 		const spyRead1 = vi.spyOn(read1, 'with');
+// 		const spyRead2 = vi.spyOn(read2, 'with');
+
+// 		db.with();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.with();
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[update] replicas postgres', () => {
+// 	it('primary update', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'update');
+// 		const spyRead1 = vi.spyOn(read1, 'update');
+// 		const spyRead2 = vi.spyOn(read2, 'update');
+
+// 		db.update({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.update({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.$primary.update({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[delete] replicas postgres', () => {
+// 	it('primary delete', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+// 		const spyRead1 = vi.spyOn(read1, 'delete');
+// 		const spyRead2 = vi.spyOn(read2, 'delete');
+
+// 		db.delete({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.delete({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.$primary.delete({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[insert] replicas postgres', () => {
+// 	it('primary insert', () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+// 		const spyRead1 = vi.spyOn(read1, 'insert');
+// 		const spyRead2 = vi.spyOn(read2, 'insert');
+
+// 		db.insert({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.insert({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.$primary.insert({} as any);
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[execute] replicas postgres', () => {
+// 	it('primary execute', async () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'execute');
+// 		const spyRead1 = vi.spyOn(read1, 'execute');
+// 		const spyRead2 = vi.spyOn(read2, 'execute');
+
+// 		// expect(db.execute(sql``)).rejects.toThrow();
+
+// 		try {
+// 			db.execute(sql``);
+// 		} catch { /* empty */ }
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		try {
+// 			db.execute(sql``);
+// 		} catch { /* empty */ }
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		try {
+// 			db.execute(sql``);
+// 		} catch { /* empty */ }
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[transaction] replicas postgres', () => {
+// 	it('primary transaction', async () => {
+// 		const primaryDb = drizzle({} as any);
+// 		const read1 = drizzle({} as any);
+// 		const read2 = drizzle({} as any);
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+// 		const spyRead1 = vi.spyOn(read1, 'transaction');
+// 		const spyRead2 = vi.spyOn(read2, 'transaction');
+
+// 		expect(db.transaction(async (tx) => {
+// 			tx.select().from({} as any);
+// 		})).rejects.toThrow();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		expect(db.transaction(async (tx) => {
+// 			tx.select().from({} as any);
+// 		})).rejects.toThrow();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		expect(db.transaction(async (tx) => {
+// 			tx.select().from({} as any);
+// 		})).rejects.toThrow();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[findFirst] read replicas postgres', () => {
+// 	it('primary findFirst', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+// 		db.$primary.query.usersTable.findFirst();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+
+// 	it('random replica findFirst', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+		
+// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], () => {
+// 			return randomMockReplica();
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+// 		db.query.usersTable.findFirst();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.query.usersTable.findFirst();
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('single read replica findFirst', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+// 		db.query.usersTable.findFirst();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.query.usersTable.findFirst();
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 	});
+
+// 	it('single read replica findFirst + primary findFirst', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+		
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+
+// 		db.query.usersTable.findFirst();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.$primary.query.usersTable.findFirst();
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('always first read findFirst', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+// 			return replicas[0]!;
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+// 		db.query.usersTable.findFirst();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.query.usersTable.findFirst();
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// });
+
+// describe('[findMany] read replicas postgres', () => {
+// 	it('primary findMany', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+// 		const db = withReplicas(primaryDb, [read1, read2]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+// 		db.$primary.query.usersTable.findMany();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(0);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+
+// 	it('random replica findMany', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+		
+// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+
+// 		const db = withReplicas(primaryDb, [read1, read2], () => {
+// 			return randomMockReplica();
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+// 		db.query.usersTable.findMany();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.query.usersTable.findMany();
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('single read replica findMany', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+
+// 		db.query.usersTable.findMany();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.query.usersTable.findMany();
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 	});
+
+// 	it('single read replica findMany + primary findMany', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+		
+// 		const db = withReplicas(primaryDb, [read1]);
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+
+// 		db.query.usersTable.findMany();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+
+// 		db.$primary.query.usersTable.findMany();
+// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 	});
+
+// 	it('always first read findMany', () => {
+// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+
+// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+// 			return replicas[0]!;
+// 		});
+
+// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+
+// 		db.query.usersTable.findMany();
+
+// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
+// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+
+// 		db.query.usersTable.findMany();
+// 		expect(spyRead1).toHaveBeenCalledTimes(2);
+// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+// 	});
+// eslint-disable-next-line unicorn/no-empty-file
+// });
\ No newline at end of file

From 8def9d61ae507270fd968d3e373e226e256bbfde Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Tue, 19 Sep 2023 21:46:25 -0400
Subject: [PATCH 15/72] [MySql] fixed type issue with the rest parameters
 passed to the set operator functions

 - Added a new type 'SetOperatorRestSelect' to properly handle the rest parameter

 - Added a new generic parameter TRest to properly handle the rest parameter

 - Added additional type tests for the rest parameters

 - deleted debigging strings on ValidateShape type
---
 .../query-builders/set-operators.ts           | 31 ++++++++++++---
 drizzle-orm/src/utils.ts                      |  7 ++--
 drizzle-orm/type-tests/mysql/set-operators.ts | 39 ++++++++++++++++++-
 3 files changed, 67 insertions(+), 10 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index f0ff107bf..f0af2b79a 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -55,6 +55,19 @@ type SetOperatorRightSelect<
 	>
 	: TValue;
 
+type SetOperatorRestSelect<
+	TValue extends readonly TypedQueryBuilder<any, any[]>[],
+	Valid,
+> = TValue extends [infer First, ...infer Rest]
+	? First extends MySqlSetOperatorBuilder<any, infer TSel, infer TMode, any, infer TNull>
+		? Rest extends TypedQueryBuilder<any, any[]>[] ? [
+				ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue[0]>,
+				...SetOperatorRestSelect<Rest, Valid>,
+			]
+		: ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue>
+	: never[]
+	: TValue;
+
 export interface MySqlSetOperatorBuilder<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
@@ -328,10 +341,11 @@ export function union<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 	if (restSelects.length === 0) {
 		return new MySqlSetOperator('union', false, leftSelect, rightSelect);
@@ -350,10 +364,11 @@ export function unionAll<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 	if (restSelects.length === 0) {
 		return new MySqlSetOperator('union', true, leftSelect, rightSelect);
@@ -372,10 +387,11 @@ export function intersect<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 	if (restSelects.length === 0) {
 		return new MySqlSetOperator('intersect', false, leftSelect, rightSelect);
@@ -394,10 +410,11 @@ export function intersectAll<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 	if (restSelects.length === 0) {
 		return new MySqlSetOperator('intersect', true, leftSelect, rightSelect);
@@ -416,10 +433,11 @@ export function except<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 	if (restSelects.length === 0) {
 		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
@@ -438,10 +456,11 @@ export function exceptAll<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>[]
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
 ): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
 	if (restSelects.length === 0) {
 		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index 16c92cfc1..713d88c84 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -196,9 +196,10 @@ export interface DrizzleConfig<TSchema extends Record<string, unknown> = Record<
 
 export type ValidateShape<T, ValidShape, TResult = T> = T extends ValidShape
 	? Exclude<keyof T, keyof ValidShape> extends never ? TResult
-	: Exclude<keyof T, keyof ValidShape> extends string ? `Invalid key(s): ${Exclude<keyof T, keyof ValidShape>}`
-	: 'uno'
-	: 'dos';
+	: Exclude<keyof T, keyof ValidShape> extends string
+		? DrizzleTypeError<`Invalid key(s): ${Exclude<keyof T, keyof ValidShape>}`>
+	: never
+	: never;
 
 export type KnownKeysOnly<T, U> = {
 	[K in keyof T]: K extends keyof U ? T[K] : never;
diff --git a/drizzle-orm/type-tests/mysql/set-operators.ts b/drizzle-orm/type-tests/mysql/set-operators.ts
index 4c95fa9fa..547d6cea6 100644
--- a/drizzle-orm/type-tests/mysql/set-operators.ts
+++ b/drizzle-orm/type-tests/mysql/set-operators.ts
@@ -77,7 +77,7 @@ const exceptAllTest = await db
 
 Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof exceptAllTest>>;
 
-const union2Test = await union(db.select().from(cities), db.select().from(cities));
+const union2Test = await union(db.select().from(cities), db.select().from(cities), db.select().from(cities));
 
 Expect<Equal<{ id: number; name: string; population: number | null }[], typeof union2Test>>;
 
@@ -170,3 +170,40 @@ db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
 
 // @ts-expect-error - The select on both sites must be the same shape
 db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
+
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	// @ts-expect-error - The select on rest parameter must be the same shape
+	db.select().from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: sql<number>`${cities.id}` }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+);

From 907605a465d6e4578f64ad5f2294baf6a1865fa5 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Wed, 20 Sep 2023 00:32:41 -0400
Subject: [PATCH 16/72] Added test for mysql implementation of set operators

 - fixed wring import in pg that prevented test from running

 - added tests
---
 .../pg-core/query-builders/set-operators.ts   |   4 +-
 integration-tests/tests/mysql.test.ts         | 855 ++++++++++++++++++
 2 files changed, 857 insertions(+), 2 deletions(-)

diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index 667a11d85..8dc175780 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -1,10 +1,8 @@
 import { entityKind, is } from '~/entity.ts';
 import {
-	applyMixins,
 	orderSelectedFields,
 	type Placeholder,
 	type Query,
-	QueryPromise,
 	SelectionProxyHandler,
 	SQL,
 	sql,
@@ -18,7 +16,9 @@ import type {
 	SelectMode,
 	SelectResult,
 } from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
 import { tracer } from '~/tracing.ts';
+import { applyMixins } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { PgColumn } from '../columns/common.ts';
 import type { PgDialect } from '../dialect.ts';
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index 3f05ffe25..9032f2108 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -8,6 +8,7 @@ import {
 	DefaultLogger,
 	eq,
 	gt,
+	gte,
 	inArray,
 	type InferModel,
 	Name,
@@ -20,9 +21,13 @@ import {
 	boolean,
 	date,
 	datetime,
+	except,
+	exceptAll,
 	getTableConfig,
 	getViewConfig,
 	int,
+	intersect,
+	intersectAll,
 	json,
 	mysqlEnum,
 	mysqlTable,
@@ -32,6 +37,8 @@ import {
 	text,
 	time,
 	timestamp,
+	union,
+	unionAll,
 	unique,
 	uniqueIndex,
 	uniqueKeyName,
@@ -2016,3 +2023,851 @@ test.serial('utc config for datetime', async (t) => {
 
 	await db.execute(sql`drop table if exists \`datestable\``);
 });
+
+test.serial('set operations (union) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable).union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table),
+		);
+
+	t.assert(result.length === 11);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'Jane' },
+		{ id: 3, name: 'Jack' },
+		{ id: 4, name: 'Peter' },
+		{ id: 5, name: 'Ben' },
+		{ id: 6, name: 'Jill' },
+		{ id: 7, name: 'Mary' },
+		{ id: 8, name: 'Sally' },
+	]);
+});
+
+test.serial('set operations (union) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await union(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('set operations (union all) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable).limit(2).unionAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).limit(2),
+		).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 4);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 2, name: 'London' },
+	]);
+});
+
+test.serial('set operations (union all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await unionAll(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 3);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('set operations (intersect) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable).intersect(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(gt(citiesTable.id, 1)),
+		);
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (intersect) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await intersect(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 0);
+
+	t.deepEqual(result, []);
+});
+
+test.serial('set operations (intersect all) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable).limit(2).intersectAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).limit(2),
+		).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+	]);
+});
+
+test.serial('set operations (intersect all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await intersectAll(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 1);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('set operations (except) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(citiesTable).except(
+			db
+				.select()
+				.from(citiesTable).where(gt(citiesTable.id, 1)),
+		);
+
+	t.assert(result.length === 1);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+	]);
+});
+
+test.serial('set operations (except) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await except(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable),
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (except all) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(citiesTable).exceptAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+		).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (except all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await exceptAll(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(gt(users2Table.id, 7)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 6);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'Jane' },
+		{ id: 3, name: 'Jack' },
+		{ id: 4, name: 'Peter' },
+		{ id: 5, name: 'Ben' },
+		{ id: 6, name: 'Jill' },
+		{ id: 7, name: 'Mary' },
+	]);
+});
+
+test.serial('set operations (mixed) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(citiesTable).except(
+			({ unionAll }) =>
+				unionAll(
+					db
+						.select()
+						.from(citiesTable).where(gt(citiesTable.id, 1)),
+					db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+				),
+		);
+
+	t.assert(result.length === 1);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+	]);
+});
+
+test.serial('set operations (mixed all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await union(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		except(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(gte(users2Table.id, 5)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 7)),
+		),
+		db
+			.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+	);
+
+	t.assert(result.length === 6);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+		{ id: 5, name: 'Ben' },
+		{ id: 6, name: 'Jill' },
+		{ id: 8, name: 'Sally' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});

From 8eccb828ba5a938c59fc3936f365643b6d1e5fb8 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Thu, 21 Sep 2023 00:22:24 +0300
Subject: [PATCH 17/72] Prepare for Release 0.29.0:

- Add support for unsigned integers in MySQL.
- Introduce custom names for primary keys and foreign keys to address the 64-character limit
---
 drizzle-orm/src/mysql-core/columns/bigint.ts  | 23 ++---
 drizzle-orm/src/mysql-core/columns/int.ts     | 19 +++--
 .../src/mysql-core/columns/mediumint.ts       | 17 ++--
 .../src/mysql-core/columns/smallint.ts        | 14 ++--
 drizzle-orm/src/mysql-core/columns/tinyint.ts | 14 ++--
 drizzle-orm/src/mysql-core/foreign-keys.ts    | 14 ++--
 drizzle-orm/src/mysql-core/primary-keys.ts    | 30 +++++--
 drizzle-orm/src/pg-core/foreign-keys.ts       | 10 ++-
 drizzle-orm/src/pg-core/primary-keys.ts       | 29 +++++--
 drizzle-orm/src/sqlite-core/foreign-keys.ts   | 10 ++-
 drizzle-orm/src/sqlite-core/primary-keys.ts   | 32 +++++--
 integration-tests/tests/mysql.test.ts         | 84 +++++++++++++++++++
 integration-tests/tests/pg.test.ts            | 24 +++---
 13 files changed, 243 insertions(+), 77 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/columns/bigint.ts b/drizzle-orm/src/mysql-core/columns/bigint.ts
index d87195868..c80770d22 100644
--- a/drizzle-orm/src/mysql-core/columns/bigint.ts
+++ b/drizzle-orm/src/mysql-core/columns/bigint.ts
@@ -14,12 +14,13 @@ export type MySqlBigInt53BuilderInitial<TName extends string> = MySqlBigInt53Bui
 }>;
 
 export class MySqlBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'MySqlBigInt53'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+	extends MySqlColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static readonly [entityKind]: string = 'MySqlBigInt53Builder';
 
-	constructor(name: T['name']) {
+	constructor(name: T['name'], unsigned: boolean = false) {
 		super(name, 'number', 'MySqlBigInt53');
+		this.config.unsigned = unsigned;
 	}
 
 	/** @internal */
@@ -34,12 +35,12 @@ export class MySqlBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'M
 }
 
 export class MySqlBigInt53<T extends ColumnBaseConfig<'number', 'MySqlBigInt53'>>
-	extends MySqlColumnWithAutoIncrement<T>
+	extends MySqlColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static readonly [entityKind]: string = 'MySqlBigInt53';
 
 	getSQLType(): string {
-		return 'bigint';
+		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
 	override mapFromDriverValue(value: number | string): number {
@@ -60,12 +61,13 @@ export type MySqlBigInt64BuilderInitial<TName extends string> = MySqlBigInt64Bui
 }>;
 
 export class MySqlBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'MySqlBigInt64'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+	extends MySqlColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static readonly [entityKind]: string = 'MySqlBigInt64Builder';
 
-	constructor(name: T['name']) {
+	constructor(name: T['name'], unsigned: boolean = false) {
 		super(name, 'bigint', 'MySqlBigInt64');
+		this.config.unsigned = unsigned;
 	}
 
 	/** @internal */
@@ -80,12 +82,12 @@ export class MySqlBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'M
 }
 
 export class MySqlBigInt64<T extends ColumnBaseConfig<'bigint', 'MySqlBigInt64'>>
-	extends MySqlColumnWithAutoIncrement<T>
+	extends MySqlColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
 	static readonly [entityKind]: string = 'MySqlBigInt64';
 
 	getSQLType(): string {
-		return 'bigint';
+		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
 	// eslint-disable-next-line unicorn/prefer-native-coercion-functions
@@ -96,6 +98,7 @@ export class MySqlBigInt64<T extends ColumnBaseConfig<'bigint', 'MySqlBigInt64'>
 
 interface MySqlBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
 	mode: T;
+	unsigned?: boolean;
 }
 
 export function bigint<TName extends string, TMode extends MySqlBigIntConfig['mode']>(
@@ -104,7 +107,7 @@ export function bigint<TName extends string, TMode extends MySqlBigIntConfig['mo
 ): TMode extends 'number' ? MySqlBigInt53BuilderInitial<TName> : MySqlBigInt64BuilderInitial<TName>;
 export function bigint(name: string, config: MySqlBigIntConfig) {
 	if (config.mode === 'number') {
-		return new MySqlBigInt53Builder(name);
+		return new MySqlBigInt53Builder(name, config.unsigned);
 	}
-	return new MySqlBigInt64Builder(name);
+	return new MySqlBigInt64Builder(name, config.unsigned);
 }
diff --git a/drizzle-orm/src/mysql-core/columns/int.ts b/drizzle-orm/src/mysql-core/columns/int.ts
index a3bdf5377..4fa1bb936 100644
--- a/drizzle-orm/src/mysql-core/columns/int.ts
+++ b/drizzle-orm/src/mysql-core/columns/int.ts
@@ -14,12 +14,13 @@ export type MySqlIntBuilderInitial<TName extends string> = MySqlIntBuilder<{
 }>;
 
 export class MySqlIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
 {
 	static readonly [entityKind]: string = 'MySqlIntBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: T['name'], config?: MySqlIntConfig) {
 		super(name, 'number', 'MySqlInt');
+		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
@@ -30,11 +31,13 @@ export class MySqlIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlI
 	}
 }
 
-export class MySqlInt<T extends ColumnBaseConfig<'number', 'MySqlInt'>> extends MySqlColumnWithAutoIncrement<T> {
+export class MySqlInt<T extends ColumnBaseConfig<'number', 'MySqlInt'>>
+	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
+{
 	static readonly [entityKind]: string = 'MySqlInt';
 
 	getSQLType(): string {
-		return 'int';
+		return `int${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
 	override mapFromDriverValue(value: number | string): number {
@@ -45,6 +48,10 @@ export class MySqlInt<T extends ColumnBaseConfig<'number', 'MySqlInt'>> extends
 	}
 }
 
-export function int<TName extends string>(name: TName): MySqlIntBuilderInitial<TName> {
-	return new MySqlIntBuilder(name);
+export interface MySqlIntConfig {
+	unsigned?: boolean;
+}
+
+export function int<TName extends string>(name: TName, config?: MySqlIntConfig): MySqlIntBuilderInitial<TName> {
+	return new MySqlIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/mysql-core/columns/mediumint.ts b/drizzle-orm/src/mysql-core/columns/mediumint.ts
index e17e2f368..9a9277fe0 100644
--- a/drizzle-orm/src/mysql-core/columns/mediumint.ts
+++ b/drizzle-orm/src/mysql-core/columns/mediumint.ts
@@ -3,6 +3,7 @@ import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { MySqlIntConfig } from './int.ts';
 
 export type MySqlMediumIntBuilderInitial<TName extends string> = MySqlMediumIntBuilder<{
 	name: TName;
@@ -14,12 +15,13 @@ export type MySqlMediumIntBuilderInitial<TName extends string> = MySqlMediumIntB
 }>;
 
 export class MySqlMediumIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlMediumInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
 {
 	static readonly [entityKind]: string = 'MySqlMediumIntBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: T['name'], config?: MySqlIntConfig) {
 		super(name, 'number', 'MySqlMediumInt');
+		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
@@ -34,12 +36,12 @@ export class MySqlMediumIntBuilder<T extends ColumnBuilderBaseConfig<'number', '
 }
 
 export class MySqlMediumInt<T extends ColumnBaseConfig<'number', 'MySqlMediumInt'>>
-	extends MySqlColumnWithAutoIncrement<T>
+	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
 {
 	static readonly [entityKind]: string = 'MySqlMediumInt';
 
 	getSQLType(): string {
-		return 'mediumint';
+		return `mediumint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
 	override mapFromDriverValue(value: number | string): number {
@@ -50,6 +52,9 @@ export class MySqlMediumInt<T extends ColumnBaseConfig<'number', 'MySqlMediumInt
 	}
 }
 
-export function mediumint<TName extends string>(name: TName): MySqlMediumIntBuilderInitial<TName> {
-	return new MySqlMediumIntBuilder(name);
+export function mediumint<TName extends string>(
+	name: TName,
+	config?: MySqlIntConfig,
+): MySqlMediumIntBuilderInitial<TName> {
+	return new MySqlMediumIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/mysql-core/columns/smallint.ts b/drizzle-orm/src/mysql-core/columns/smallint.ts
index e1723dbd0..18676651a 100644
--- a/drizzle-orm/src/mysql-core/columns/smallint.ts
+++ b/drizzle-orm/src/mysql-core/columns/smallint.ts
@@ -3,6 +3,7 @@ import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { MySqlIntConfig } from './int.ts';
 
 export type MySqlSmallIntBuilderInitial<TName extends string> = MySqlSmallIntBuilder<{
 	name: TName;
@@ -14,12 +15,13 @@ export type MySqlSmallIntBuilderInitial<TName extends string> = MySqlSmallIntBui
 }>;
 
 export class MySqlSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlSmallInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
 {
 	static readonly [entityKind]: string = 'MySqlSmallIntBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: T['name'], config?: MySqlIntConfig) {
 		super(name, 'number', 'MySqlSmallInt');
+		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
@@ -34,12 +36,12 @@ export class MySqlSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'M
 }
 
 export class MySqlSmallInt<T extends ColumnBaseConfig<'number', 'MySqlSmallInt'>>
-	extends MySqlColumnWithAutoIncrement<T>
+	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
 {
 	static readonly [entityKind]: string = 'MySqlSmallInt';
 
 	getSQLType(): string {
-		return 'smallint';
+		return `smallint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
 	override mapFromDriverValue(value: number | string): number {
@@ -50,6 +52,6 @@ export class MySqlSmallInt<T extends ColumnBaseConfig<'number', 'MySqlSmallInt'>
 	}
 }
 
-export function smallint<TName extends string>(name: TName): MySqlSmallIntBuilderInitial<TName> {
-	return new MySqlSmallIntBuilder(name);
+export function smallint<TName extends string>(name: TName, config?: MySqlIntConfig): MySqlSmallIntBuilderInitial<TName> {
+	return new MySqlSmallIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/mysql-core/columns/tinyint.ts b/drizzle-orm/src/mysql-core/columns/tinyint.ts
index 1fdef4e61..35a68cbd2 100644
--- a/drizzle-orm/src/mysql-core/columns/tinyint.ts
+++ b/drizzle-orm/src/mysql-core/columns/tinyint.ts
@@ -3,6 +3,7 @@ import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
 import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { MySqlIntConfig } from './int.ts';
 
 export type MySqlTinyIntBuilderInitial<TName extends string> = MySqlTinyIntBuilder<{
 	name: TName;
@@ -14,12 +15,13 @@ export type MySqlTinyIntBuilderInitial<TName extends string> = MySqlTinyIntBuild
 }>;
 
 export class MySqlTinyIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlTinyInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
 {
 	static readonly [entityKind]: string = 'MySqlTinyIntBuilder';
 
-	constructor(name: T['name']) {
+	constructor(name: T['name'], config?: MySqlIntConfig) {
 		super(name, 'number', 'MySqlTinyInt');
+		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
@@ -34,12 +36,12 @@ export class MySqlTinyIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'My
 }
 
 export class MySqlTinyInt<T extends ColumnBaseConfig<'number', 'MySqlTinyInt'>>
-	extends MySqlColumnWithAutoIncrement<T>
+	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
 {
 	static readonly [entityKind]: string = 'MySqlTinyInt';
 
 	getSQLType(): string {
-		return 'tinyint';
+		return `tinyint${this.config.unsigned ? ' unsigned' : ''}`;
 	}
 
 	override mapFromDriverValue(value: number | string): number {
@@ -50,6 +52,6 @@ export class MySqlTinyInt<T extends ColumnBaseConfig<'number', 'MySqlTinyInt'>>
 	}
 }
 
-export function tinyint<TName extends string>(name: TName): MySqlTinyIntBuilderInitial<TName> {
-	return new MySqlTinyIntBuilder(name);
+export function tinyint<TName extends string>(name: TName, config?: MySqlIntConfig): MySqlTinyIntBuilderInitial<TName> {
+	return new MySqlTinyIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/mysql-core/foreign-keys.ts b/drizzle-orm/src/mysql-core/foreign-keys.ts
index 8f9abdae8..5ae3d5324 100644
--- a/drizzle-orm/src/mysql-core/foreign-keys.ts
+++ b/drizzle-orm/src/mysql-core/foreign-keys.ts
@@ -5,6 +5,7 @@ import { MySqlTable } from './table.ts';
 export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
 
 export type Reference = () => {
+	readonly name?: string;
 	readonly columns: MySqlColumn[];
 	readonly foreignTable: MySqlTable;
 	readonly foreignColumns: MySqlColumn[];
@@ -24,6 +25,7 @@ export class ForeignKeyBuilder {
 
 	constructor(
 		config: () => {
+			name?: string;
 			columns: MySqlColumn[];
 			foreignColumns: MySqlColumn[];
 		},
@@ -33,8 +35,8 @@ export class ForeignKeyBuilder {
 		} | undefined,
 	) {
 		this.reference = () => {
-			const { columns, foreignColumns } = config();
-			return { columns, foreignTable: foreignColumns[0]!.table as MySqlTable, foreignColumns };
+			const { name, columns, foreignColumns } = config();
+			return { name, columns, foreignTable: foreignColumns[0]!.table as MySqlTable, foreignColumns };
 		};
 		if (actions) {
 			this._onUpdate = actions.onUpdate;
@@ -74,7 +76,7 @@ export class ForeignKey {
 	}
 
 	getName(): string {
-		const { columns, foreignColumns } = this.reference();
+		const { name, columns, foreignColumns } = this.reference();
 		const columnNames = columns.map((column) => column.name);
 		const foreignColumnNames = foreignColumns.map((column) => column.name);
 		const chunks = [
@@ -83,7 +85,7 @@ export class ForeignKey {
 			foreignColumns[0]!.table[MySqlTable.Symbol.Name],
 			...foreignColumnNames,
 		];
-		return `${chunks.join('_')}_fk`;
+		return name ?? `${chunks.join('_')}_fk`;
 	}
 }
 
@@ -105,13 +107,15 @@ export function foreignKey<
 	TColumns extends [AnyMySqlColumn<{ tableName: TTableName }>, ...AnyMySqlColumn<{ tableName: TTableName }>[]],
 >(
 	config: {
+		name?: string,
 		columns: TColumns;
 		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
 	},
 ): ForeignKeyBuilder {
 	function mappedConfig() {
-		const { columns, foreignColumns } = config;
+		const { name, columns, foreignColumns } = config;
 		return {
+			name,
 			columns,
 			foreignColumns,
 		};
diff --git a/drizzle-orm/src/mysql-core/primary-keys.ts b/drizzle-orm/src/mysql-core/primary-keys.ts
index 26bd3edca..bb7e83a64 100644
--- a/drizzle-orm/src/mysql-core/primary-keys.ts
+++ b/drizzle-orm/src/mysql-core/primary-keys.ts
@@ -2,11 +2,23 @@ import { entityKind } from '~/entity.ts';
 import type { AnyMySqlColumn, MySqlColumn } from './columns/index.ts';
 import { MySqlTable } from './table.ts';
 
+export function primaryKey<
+	TTableName extends string,
+	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>,
+>(config: { name?: string; columns: [TColumns, ...TColumns[]] }): PrimaryKeyBuilder;
+/**
+ * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
+ * @param columns
+ */
 export function primaryKey<
 	TTableName extends string,
 	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>[],
->(...columns: TColumns): PrimaryKeyBuilder {
-	return new PrimaryKeyBuilder(columns);
+>(...columns: TColumns): PrimaryKeyBuilder;
+export function primaryKey(config: any) {
+	if (config.name) {
+		return new PrimaryKeyBuilder(config.columns, config.name);
+	}
+	return new PrimaryKeyBuilder(config);
 }
 
 export class PrimaryKeyBuilder {
@@ -15,15 +27,20 @@ export class PrimaryKeyBuilder {
 	/** @internal */
 	columns: MySqlColumn[];
 
+	/** @internal */
+	name?: string;
+
 	constructor(
 		columns: MySqlColumn[],
+		name?: string,
 	) {
 		this.columns = columns;
+		this.name = name;
 	}
 
 	/** @internal */
 	build(table: MySqlTable): PrimaryKey {
-		return new PrimaryKey(table, this.columns);
+		return new PrimaryKey(table, this.columns, this.name);
 	}
 }
 
@@ -31,12 +48,15 @@ export class PrimaryKey {
 	static readonly [entityKind]: string = 'MySqlPrimaryKey';
 
 	readonly columns: MySqlColumn[];
+	readonly name?: string;
 
-	constructor(readonly table: MySqlTable, columns: MySqlColumn[]) {
+	constructor(readonly table: MySqlTable, columns: MySqlColumn[], name?: string) {
 		this.columns = columns;
+		this.name = name;
 	}
 
 	getName(): string {
-		return `${this.table[MySqlTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
+		return this.name
+			?? `${this.table[MySqlTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
 	}
 }
diff --git a/drizzle-orm/src/pg-core/foreign-keys.ts b/drizzle-orm/src/pg-core/foreign-keys.ts
index 31fc00d41..e7864bd71 100644
--- a/drizzle-orm/src/pg-core/foreign-keys.ts
+++ b/drizzle-orm/src/pg-core/foreign-keys.ts
@@ -5,6 +5,7 @@ import { PgTable } from './table.ts';
 export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
 
 export type Reference = () => {
+	readonly name?: string;
 	readonly columns: PgColumn[];
 	readonly foreignTable: PgTable;
 	readonly foreignColumns: PgColumn[];
@@ -24,6 +25,7 @@ export class ForeignKeyBuilder {
 
 	constructor(
 		config: () => {
+			name?: string,
 			columns: PgColumn[];
 			foreignColumns: PgColumn[];
 		},
@@ -33,8 +35,8 @@ export class ForeignKeyBuilder {
 		} | undefined,
 	) {
 		this.reference = () => {
-			const { columns, foreignColumns } = config();
-			return { columns, foreignTable: foreignColumns[0]!.table as PgTable, foreignColumns };
+			const { name, columns, foreignColumns } = config();
+			return { name, columns, foreignTable: foreignColumns[0]!.table as PgTable, foreignColumns };
 		};
 		if (actions) {
 			this._onUpdate = actions.onUpdate;
@@ -74,7 +76,7 @@ export class ForeignKey {
 	}
 
 	getName(): string {
-		const { columns, foreignColumns } = this.reference();
+		const { name, columns, foreignColumns } = this.reference();
 		const columnNames = columns.map((column) => column.name);
 		const foreignColumnNames = foreignColumns.map((column) => column.name);
 		const chunks = [
@@ -83,7 +85,7 @@ export class ForeignKey {
 			foreignColumns[0]!.table[PgTable.Symbol.Name],
 			...foreignColumnNames,
 		];
-		return `${chunks.join('_')}_fk`;
+		return name ?? `${chunks.join('_')}_fk`;
 	}
 }
 
diff --git a/drizzle-orm/src/pg-core/primary-keys.ts b/drizzle-orm/src/pg-core/primary-keys.ts
index 113471192..266f55e2f 100644
--- a/drizzle-orm/src/pg-core/primary-keys.ts
+++ b/drizzle-orm/src/pg-core/primary-keys.ts
@@ -2,11 +2,23 @@ import { entityKind } from '~/entity.ts';
 import type { AnyPgColumn, PgColumn } from './columns/index.ts';
 import { PgTable } from './table.ts';
 
+export function primaryKey<
+	TTableName extends string,
+	TColumns extends AnyPgColumn<{ tableName: TTableName }>,
+>(config: { name?: string; columns: [TColumns, ...TColumns[]] }): PrimaryKeyBuilder;
+/**
+ * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
+ * @param columns 
+ */
 export function primaryKey<
 	TTableName extends string,
 	TColumns extends AnyPgColumn<{ tableName: TTableName }>[],
->(...columns: TColumns): PrimaryKeyBuilder {
-	return new PrimaryKeyBuilder(columns);
+>(...columns: TColumns): PrimaryKeyBuilder;
+export function primaryKey(config: any) {
+	if (config.name) {
+		return new PrimaryKeyBuilder(config.columns, config.name);
+	}
+	return new PrimaryKeyBuilder(config);
 }
 
 export class PrimaryKeyBuilder {
@@ -15,15 +27,20 @@ export class PrimaryKeyBuilder {
 	/** @internal */
 	columns: PgColumn[];
 
+	/** @internal */
+	name?: string;
+
 	constructor(
 		columns: PgColumn[],
+		name?: string,
 	) {
 		this.columns = columns;
+		this.name = name;
 	}
 
 	/** @internal */
 	build(table: PgTable): PrimaryKey {
-		return new PrimaryKey(table, this.columns);
+		return new PrimaryKey(table, this.columns, this.name);
 	}
 }
 
@@ -31,12 +48,14 @@ export class PrimaryKey {
 	static readonly [entityKind]: string = 'PgPrimaryKey';
 
 	readonly columns: AnyPgColumn<{}>[];
+	readonly name?: string;
 
-	constructor(readonly table: PgTable, columns: AnyPgColumn<{}>[]) {
+	constructor(readonly table: PgTable, columns: AnyPgColumn<{}>[], name?: string) {
 		this.columns = columns;
+		this.name = name;
 	}
 
 	getName(): string {
-		return `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
+		return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
 	}
 }
diff --git a/drizzle-orm/src/sqlite-core/foreign-keys.ts b/drizzle-orm/src/sqlite-core/foreign-keys.ts
index 1aab5c765..76a8a529c 100644
--- a/drizzle-orm/src/sqlite-core/foreign-keys.ts
+++ b/drizzle-orm/src/sqlite-core/foreign-keys.ts
@@ -5,6 +5,7 @@ import { SQLiteTable } from './table.ts';
 export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
 
 export type Reference = () => {
+	readonly name?: string;
 	readonly columns: SQLiteColumn[];
 	readonly foreignTable: SQLiteTable;
 	readonly foreignColumns: SQLiteColumn[];
@@ -29,6 +30,7 @@ export class ForeignKeyBuilder {
 
 	constructor(
 		config: () => {
+			name?: string;
 			columns: SQLiteColumn[];
 			foreignColumns: SQLiteColumn[];
 		},
@@ -38,8 +40,8 @@ export class ForeignKeyBuilder {
 		} | undefined,
 	) {
 		this.reference = () => {
-			const { columns, foreignColumns } = config();
-			return { columns, foreignTable: foreignColumns[0]!.table as SQLiteTable, foreignColumns };
+			const { name, columns, foreignColumns } = config();
+			return { name, columns, foreignTable: foreignColumns[0]!.table as SQLiteTable, foreignColumns };
 		};
 		if (actions) {
 			this._onUpdate = actions.onUpdate;
@@ -77,7 +79,7 @@ export class ForeignKey {
 	}
 
 	getName(): string {
-		const { columns, foreignColumns } = this.reference();
+		const { name, columns, foreignColumns } = this.reference();
 		const columnNames = columns.map((column) => column.name);
 		const foreignColumnNames = foreignColumns.map((column) => column.name);
 		const chunks = [
@@ -86,7 +88,7 @@ export class ForeignKey {
 			foreignColumns[0]!.table[SQLiteTable.Symbol.Name],
 			...foreignColumnNames,
 		];
-		return `${chunks.join('_')}_fk`;
+		return name ?? `${chunks.join('_')}_fk`;
 	}
 }
 
diff --git a/drizzle-orm/src/sqlite-core/primary-keys.ts b/drizzle-orm/src/sqlite-core/primary-keys.ts
index 5285eacbd..ee132f8e5 100644
--- a/drizzle-orm/src/sqlite-core/primary-keys.ts
+++ b/drizzle-orm/src/sqlite-core/primary-keys.ts
@@ -2,15 +2,24 @@ import { entityKind } from '~/entity.ts';
 import type { AnySQLiteColumn, SQLiteColumn } from './columns/index.ts';
 import { SQLiteTable } from './table.ts';
 
+export function primaryKey<
+	TTableName extends string,
+	TColumns extends AnySQLiteColumn<{ tableName: TTableName }>,
+>(config: { name?: string; columns: [TColumns, ...TColumns[]] }): PrimaryKeyBuilder;
+/**
+ * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
+ * @param columns
+ */
 export function primaryKey<
 	TTableName extends string,
 	TColumns extends AnySQLiteColumn<{ tableName: TTableName }>[],
->(
-	...columns: TColumns
-): PrimaryKeyBuilder {
-	return new PrimaryKeyBuilder(columns);
+>(...columns: TColumns): PrimaryKeyBuilder;
+export function primaryKey(config: any) {
+	if (config.name) {
+		return new PrimaryKeyBuilder(config.columns, config.name);
+	}
+	return new PrimaryKeyBuilder(config);
 }
-
 export class PrimaryKeyBuilder {
 	static readonly [entityKind]: string = 'SQLitePrimaryKeyBuilder';
 
@@ -21,15 +30,20 @@ export class PrimaryKeyBuilder {
 	/** @internal */
 	columns: SQLiteColumn[];
 
+	/** @internal */
+	name?: string;
+
 	constructor(
 		columns: SQLiteColumn[],
+		name?: string,
 	) {
 		this.columns = columns;
+		this.name = name;
 	}
 
 	/** @internal */
 	build(table: SQLiteTable): PrimaryKey {
-		return new PrimaryKey(table, this.columns);
+		return new PrimaryKey(table, this.columns, this.name);
 	}
 }
 
@@ -37,12 +51,14 @@ export class PrimaryKey {
 	static readonly [entityKind]: string = 'SQLitePrimaryKey';
 
 	readonly columns: SQLiteColumn[];
+	readonly name?: string;
 
-	constructor(readonly table: SQLiteTable, columns: SQLiteColumn[]) {
+	constructor(readonly table: SQLiteTable, columns: SQLiteColumn[], name?: string) {
 		this.columns = columns;
+		this.name = name;
 	}
 
 	getName(): string {
-		return `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
+		return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
 	}
 }
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index 3f05ffe25..373c953e4 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -17,21 +17,27 @@ import {
 } from 'drizzle-orm';
 import {
 	alias,
+	bigint,
 	boolean,
 	date,
 	datetime,
+	foreignKey,
 	getTableConfig,
 	getViewConfig,
 	int,
 	json,
+	mediumint,
 	mysqlEnum,
 	mysqlTable,
 	mysqlTableCreator,
 	mysqlView,
+	primaryKey,
 	serial,
+	smallint,
 	text,
 	time,
 	timestamp,
+	tinyint,
 	unique,
 	uniqueIndex,
 	uniqueKeyName,
@@ -215,6 +221,84 @@ test.beforeEach(async (t) => {
 	);
 });
 
+test.serial.only('table config: unsigned ints', async (t) => {
+	const unsignedInts = mysqlTable('cities1', {
+		bigint: bigint('bigint', { mode: 'number', unsigned: true }),
+		int: int('int', { unsigned: true }),
+		smallint: smallint('smallint', { unsigned: true }),
+		mediumint: mediumint('mediumint', { unsigned: true }),
+		tinyint: tinyint('tinyint', { unsigned: true }),
+	});
+
+	const tableConfig = getTableConfig(unsignedInts);
+
+	const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+	const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+	const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+	const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+	const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+	t.is(bigintColumn.getSQLType(), 'bigint unsigned');
+	t.is(intColumn.getSQLType(), 'int unsigned');
+	t.is(smallintColumn.getSQLType(), 'smallint unsigned');
+	t.is(mediumintColumn.getSQLType(), 'mediumint unsigned');
+	t.is(tinyintColumn.getSQLType(), 'tinyint unsigned');
+});
+
+test.serial.only('table config: signed ints', async (t) => {
+	const unsignedInts = mysqlTable('cities1', {
+		bigint: bigint('bigint', { mode: 'number' }),
+		int: int('int'),
+		smallint: smallint('smallint'),
+		mediumint: mediumint('mediumint'),
+		tinyint: tinyint('tinyint'),
+	});
+
+	const tableConfig = getTableConfig(unsignedInts);
+
+	const bigintColumn = tableConfig.columns.find((c) => c.name === 'bigint')!;
+	const intColumn = tableConfig.columns.find((c) => c.name === 'int')!;
+	const smallintColumn = tableConfig.columns.find((c) => c.name === 'smallint')!;
+	const mediumintColumn = tableConfig.columns.find((c) => c.name === 'mediumint')!;
+	const tinyintColumn = tableConfig.columns.find((c) => c.name === 'tinyint')!;
+
+	t.is(bigintColumn.getSQLType(), 'bigint');
+	t.is(intColumn.getSQLType(), 'int');
+	t.is(smallintColumn.getSQLType(), 'smallint');
+	t.is(mediumintColumn.getSQLType(), 'mediumint');
+	t.is(tinyintColumn.getSQLType(), 'tinyint');
+});
+
+test.serial.only('table config: foreign keys name', async (t) => {
+	const table = mysqlTable('cities', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
+	}));
+
+	const tableConfig = getTableConfig(table);
+
+	t.is(tableConfig.foreignKeys.length, 1);
+	t.is(tableConfig.foreignKeys[0]!.getName(), 'custom_fk');
+});
+
+test.serial.only('table config: primary keys name', async (t) => {
+	const table = mysqlTable('cities', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
+	}));
+
+	const tableConfig = getTableConfig(table);
+
+	t.is(tableConfig.primaryKeys.length, 1);
+	t.is(tableConfig.primaryKeys[0]!.getName(), 'custom_pk');
+});
+
 test.serial('table configs: unique third param', async (t) => {
 	const cities1Table = mysqlTable('cities1', {
 		id: serial('id').primaryKey(),
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index fb2f058f6..b2135112b 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -5,6 +5,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	eq,
 	gt,
@@ -17,9 +20,6 @@ import {
 	sql,
 	type SQLWrapper,
 	TransactionRollbackError,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
 import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
@@ -2465,7 +2465,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2475,17 +2475,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2497,11 +2497,11 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });

From 3893876dff4c97618cd5dd9d23d4b8d4f2efbcd3 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Wed, 20 Sep 2023 21:57:35 -0400
Subject: [PATCH 18/72] [Pg] Completed implementation of set operations

 - Added abstract class PgSetOperatorBuilder that extends the TypedQueryBuilder

 - Added type helpers for correct type inference including when passing multiple parameters to the function form

 - PgSelect now extends from PgSetOperatorBuilder instead of TypedQueryBuilder to inherit all its methods
---
 .../src/pg-core/query-builders/select.ts      | 130 +------
 .../pg-core/query-builders/set-operators.ts   | 341 +++++++++++++-----
 2 files changed, 251 insertions(+), 220 deletions(-)

diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index 734de066e..4ebb7b876 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -5,7 +5,6 @@ import type { PgSession, PreparedQuery, PreparedQueryConfig } from '~/pg-core/se
 import type { SubqueryWithSelection } from '~/pg-core/subquery.ts';
 import type { PgTable } from '~/pg-core/table.ts';
 import { PgViewBase } from '~/pg-core/view.ts';
-import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
 	GetSelectTableName,
@@ -33,7 +32,7 @@ import type {
 	PgSelectQueryBuilderHKT,
 	SelectedFields,
 } from './select.types.ts';
-import { PgSetOperator } from './set-operators.ts';
+import { PgSetOperatorBuilder } from './set-operators.ts';
 
 type CreatePgSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
@@ -130,9 +129,12 @@ export abstract class PgSelectQueryBuilder<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> extends PgSetOperatorBuilder<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap
 > {
 	static readonly [entityKind]: string = 'PgSelectQueryBuilder';
 
@@ -180,16 +182,6 @@ export abstract class PgSelectQueryBuilder<
 		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
 	}
 
-	/** @internal */
-	getSetOperatorConfig() {
-		return {
-			session: this.session,
-			dialect: this.dialect,
-			joinsNotNullableMap: this.joinsNotNullableMap,
-			fields: this.config.fields,
-		};
-	}
-
 	private createJoin<TJoinType extends JoinType>(
 		joinType: TJoinType,
 	): JoinFn<THKT, TTableName, TSelectMode, TJoinType, TSelection, TNullabilityMap> {
@@ -325,114 +317,6 @@ export abstract class PgSelectQueryBuilder<
 		return this;
 	}
 
-	union<
-		THKT extends PgSelectHKTBase,
-		TTableName extends string | undefined,
-		TSelection extends ColumnsSelection,
-		TSelectMode extends SelectMode,
-	>(
-		rightSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	): PgSetOperator<
-		THKT,
-		TTableName,
-		TSelection,
-		TSelectMode
-	> {
-		return new PgSetOperator('union', false, this as any, rightSelect);
-	}
-
-	unionAll<
-		THKT extends PgSelectHKTBase,
-		TTableName extends string | undefined,
-		TSelection extends ColumnsSelection,
-		TSelectMode extends SelectMode,
-	>(
-		rightSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	): PgSetOperator<
-		THKT,
-		TTableName,
-		TSelection,
-		TSelectMode
-	> {
-		return new PgSetOperator('union', true, this as any, rightSelect);
-	}
-
-	intersect<
-		THKT extends PgSelectHKTBase,
-		TTableName extends string | undefined,
-		TSelection extends ColumnsSelection,
-		TSelectMode extends SelectMode,
-	>(
-		rightSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	): PgSetOperator<
-		THKT,
-		TTableName,
-		TSelection,
-		TSelectMode
-	> {
-		return new PgSetOperator('intersect', false, this as any, rightSelect);
-	}
-
-	intersectAll<
-		THKT extends PgSelectHKTBase,
-		TTableName extends string | undefined,
-		TSelection extends ColumnsSelection,
-		TSelectMode extends SelectMode,
-	>(
-		rightSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	): PgSetOperator<
-		THKT,
-		TTableName,
-		TSelection,
-		TSelectMode
-	> {
-		return new PgSetOperator('intersect', true, this as any, rightSelect);
-	}
-
-	except<
-		THKT extends PgSelectHKTBase,
-		TTableName extends string | undefined,
-		TSelection extends ColumnsSelection,
-		TSelectMode extends SelectMode,
-	>(
-		rightSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	): PgSetOperator<
-		THKT,
-		TTableName,
-		TSelection,
-		TSelectMode
-	> {
-		return new PgSetOperator('except', false, this as any, rightSelect);
-	}
-
-	exceptAll<
-		THKT extends PgSelectHKTBase,
-		TTableName extends string | undefined,
-		TSelection extends ColumnsSelection,
-		TSelectMode extends SelectMode,
-	>(
-		rightSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	): PgSetOperator<
-		THKT,
-		TTableName,
-		TSelection,
-		TSelectMode
-	> {
-		return new PgSetOperator('except', true, this as any, rightSelect);
-	}
-
 	/**
 	 * Sets the HAVING clause of this query, which often
 	 * used with GROUP BY and filters rows after they've been
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index 8dc175780..05af888e1 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -18,15 +18,151 @@ import type {
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import { tracer } from '~/tracing.ts';
-import { applyMixins } from '~/utils.ts';
+import { applyMixins, type ValidateShape } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { PgColumn } from '../columns/common.ts';
 import type { PgDialect } from '../dialect.ts';
-import type { PgSelect, PgSelectQueryBuilder } from './select.ts';
-import type { PgSelectHKTBase, PgSelectQueryBuilderHKT } from './select.types.ts';
+import type { PgSelectHKTBase } from './select.types.ts';
 
 type SetOperator = 'union' | 'intersect' | 'except';
 
+const getPgSetOperators = () => {
+	return {
+		union,
+		unionAll,
+		intersect,
+		intersectAll,
+		except,
+		exceptAll,
+	};
+};
+
+type PgSetOperators = ReturnType<typeof getPgSetOperators>;
+
+type SetOperatorRightSelect<
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+> = TValue extends PgSetOperatorBuilder<any, any, infer TSel, infer TMode, infer TNull> ? ValidateShape<
+		SelectResult<TSel, TMode, TNull>,
+		SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+		TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	>
+	: TValue;
+
+type SetOperatorRestSelect<
+	TValue extends readonly TypedQueryBuilder<any, any[]>[],
+	Valid,
+> = TValue extends [infer First, ...infer Rest]
+	? First extends PgSetOperatorBuilder<any, any, infer TSel, infer TMode, infer TNull>
+		? Rest extends TypedQueryBuilder<any, any[]>[] ? [
+				ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue[0]>,
+				...SetOperatorRestSelect<Rest, Valid>,
+			]
+		: ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue>
+	: never[]
+	: TValue;
+
+export abstract class PgSetOperatorBuilder<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends TypedQueryBuilder<
+	BuildSubquerySelection<TSelection, TNullabilityMap>,
+	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> {
+	static readonly [entityKind]: string = 'PgSetOperatorBuilder';
+
+	protected abstract joinsNotNullableMap: Record<string, boolean>;
+	protected abstract config: {
+		fields: Record<string, unknown>;
+		limit?: number | Placeholder;
+		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+	};
+	/* @internal */
+	protected abstract readonly session: PgSession | undefined;
+	protected abstract dialect: PgDialect;
+
+	/** @internal */
+	getSetOperatorConfig() {
+		return {
+			session: this.session,
+			dialect: this.dialect,
+			joinsNotNullableMap: this.joinsNotNullableMap,
+			fields: this.config.fields,
+		};
+	}
+	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+
+		return new PgSetOperator('union', false, this, rightSelectOrig);
+	}
+
+	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+
+		return new PgSetOperator('union', true, this, rightSelectOrig);
+	}
+
+	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+
+		return new PgSetOperator('intersect', false, this, rightSelectOrig);
+	}
+
+	intersectAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+
+		return new PgSetOperator('intersect', true, this, rightSelectOrig);
+	}
+
+	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+
+		return new PgSetOperator('except', false, this, rightSelectOrig);
+	}
+
+	exceptAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+
+		return new PgSetOperator('except', true, this, rightSelectOrig);
+	}
+
+	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
+	abstract orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+
+	abstract limit(limit: number): this;
+}
+
 export interface PgSetOperator<
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	THKT extends PgSelectHKTBase,
@@ -44,46 +180,45 @@ export interface PgSetOperator<
 {}
 
 export class PgSetOperator<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> extends PgSetOperatorBuilder<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap
 > {
 	static readonly [entityKind]: string = 'PgSetOperator';
 
-	private session: PgSession | undefined;
-	private dialect: PgDialect;
-	private config: {
+	protected joinsNotNullableMap: Record<string, boolean>;
+	protected config: {
 		fields: Record<string, unknown>;
-		joinsNotNullableMap: Record<string, boolean>;
 		limit?: number | Placeholder;
 		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
 	};
+	/* @internal */
+	readonly session: PgSession | undefined;
+	protected dialect: PgDialect;
 
 	constructor(
 		private operator: SetOperator,
 		private isAll: boolean,
-		private leftSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-		private rightSelect:
-			| PgSelect<TTableName, TSelection, TSelectMode>
-			| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
+		private leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+		private rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
 		super();
 
 		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
 		this.session = session;
 		this.dialect = dialect;
+		this.joinsNotNullableMap = joinsNotNullableMap;
 		this.config = {
 			fields,
-			joinsNotNullableMap,
 		};
 	}
 
@@ -161,7 +296,7 @@ export class PgSetOperator<
 			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
 		}
 	> {
-		const { session, config: { fields, joinsNotNullableMap }, dialect } = this;
+		const { session, joinsNotNullableMap, config: { fields }, dialect } = this;
 		if (!session) {
 			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
 		}
@@ -204,20 +339,22 @@ export function union<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
-	leftSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	rightSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-): PgSetOperator<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode
-> {
-	return new PgSetOperator('union', false, leftSelect, rightSelect);
+	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new PgSetOperator('union', false, leftSelect, rightSelect);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return union(new PgSetOperator('union', false, leftSelect, rightSelect), select, ...rest);
 }
 
 export function unionAll<
@@ -225,20 +362,22 @@ export function unionAll<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
-	leftSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	rightSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-): PgSetOperator<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode
-> {
-	return new PgSetOperator('union', true, leftSelect, rightSelect);
+	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new PgSetOperator('union', true, leftSelect, rightSelect);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return unionAll(new PgSetOperator('union', true, leftSelect, rightSelect), select, ...rest);
 }
 
 export function intersect<
@@ -246,20 +385,22 @@ export function intersect<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
-	leftSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	rightSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-): PgSetOperator<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode
-> {
-	return new PgSetOperator('intersect', false, leftSelect, rightSelect);
+	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new PgSetOperator('intersect', false, leftSelect, rightSelect);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return intersect(new PgSetOperator('intersect', false, leftSelect, rightSelect!), select, ...rest);
 }
 
 export function intersectAll<
@@ -267,20 +408,22 @@ export function intersectAll<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
-	leftSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	rightSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-): PgSetOperator<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode
-> {
-	return new PgSetOperator('intersect', true, leftSelect, rightSelect);
+	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new PgSetOperator('intersect', true, leftSelect, rightSelect);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return intersectAll(new PgSetOperator('intersect', true, leftSelect, rightSelect!), select, ...rest);
 }
 
 export function except<
@@ -288,20 +431,22 @@ export function except<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
-	leftSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	rightSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-): PgSetOperator<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode
-> {
-	return new PgSetOperator('except', false, leftSelect, rightSelect);
+	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new PgSetOperator('except', false, leftSelect, rightSelect);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return except(new PgSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
 }
 
 export function exceptAll<
@@ -309,18 +454,20 @@ export function exceptAll<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
-	leftSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-	rightSelect:
-		| PgSelect<TTableName, TSelection, TSelectMode>
-		| PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>,
-): PgSetOperator<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode
-> {
-	return new PgSetOperator('except', true, leftSelect, rightSelect);
+	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new PgSetOperator('except', false, leftSelect, rightSelect);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return exceptAll(new PgSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
 }

From 87479a7e55da1d0eb4a6508c4aadc68474ed7a2d Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Wed, 20 Sep 2023 21:58:43 -0400
Subject: [PATCH 19/72] [Pg] Added type tests for the set operators

---
 drizzle-orm/type-tests/pg/set-operators.ts | 194 +++++++++++++++++++++
 1 file changed, 194 insertions(+)
 create mode 100644 drizzle-orm/type-tests/pg/set-operators.ts

diff --git a/drizzle-orm/type-tests/pg/set-operators.ts b/drizzle-orm/type-tests/pg/set-operators.ts
new file mode 100644
index 000000000..06c1c9bef
--- /dev/null
+++ b/drizzle-orm/type-tests/pg/set-operators.ts
@@ -0,0 +1,194 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import { eq } from '~/expressions.ts';
+import { except, exceptAll, intersect, intersectAll, union, unionAll } from '~/pg-core/index.ts';
+import { desc, sql } from '~/sql/index.ts';
+import { db } from './db.ts';
+import { cities, classes, newYorkers, users } from './tables.ts';
+
+const unionTest = await db
+	.select({ id: users.id })
+	.from(users)
+	.union(
+		db
+			.select({ id: users.id })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number }[], typeof unionTest>>;
+
+const unionAllTest = await db
+	.select({ id: users.id, text: users.text })
+	.from(users)
+	.unionAll(
+		db.select({ id: users.id, text: users.text })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; text: string | null }[], typeof unionAllTest>>;
+
+const intersectTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.intersect(({ intersect }) =>
+		intersect(
+			db
+				.select({ id: users.id, homeCity: users.homeCity })
+				.from(users),
+			db
+				.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+				.from(users),
+		)
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
+
+const intersectAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.intersectAll(
+		db
+			.select({ id: users.id, homeCity: users.class })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof intersectAllTest>>;
+
+const exceptTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
+
+const exceptAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.exceptAll(
+		db
+			.select({ id: users.id, homeCity: sql<'A' | 'C'>`${users.class}` })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof exceptAllTest>>;
+
+const union2Test = await union(db.select().from(cities), db.select().from(cities), db.select().from(cities));
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof union2Test>>;
+
+const unionAll2Test = await unionAll(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select().from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof unionAll2Test>>;
+
+const intersect2Test = await intersect(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
+
+const intersectAll2Test = await intersectAll(
+	db.select({
+		id: cities.id,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+	})
+		.from(cities),
+).orderBy(desc(cities.id)).limit(23);
+
+Expect<Equal<{ id: number }[], typeof intersectAll2Test>>;
+
+const except2Test = await except(
+	db.select({
+		userId: newYorkers.userId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number }[], typeof except2Test>>;
+
+const exceptAll2Test = await exceptAll(
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
+
+// @ts-expect-error - The select on both sites must be the same shape
+db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
+
+// @ts-expect-error - The select on both sites must be the same shape
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
+
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	// @ts-expect-error - The select on rest parameter must be the same shape
+	db.select().from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: sql<number>`${cities.id}` }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+);

From 4e371fb13cac28e468d620968d79e5f52dce8c5d Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Wed, 20 Sep 2023 21:59:08 -0400
Subject: [PATCH 20/72] [Pg] Added integration tests for the set operators

---
 integration-tests/tests/pg.test.ts | 869 ++++++++++++++++++++++++++++-
 1 file changed, 857 insertions(+), 12 deletions(-)

diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index fb2f058f6..d69f12555 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -5,6 +5,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	eq,
 	gt,
@@ -17,9 +20,6 @@ import {
 	sql,
 	type SQLWrapper,
 	TransactionRollbackError,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
 import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
@@ -28,11 +28,15 @@ import {
 	boolean,
 	char,
 	cidr,
+	except,
+	exceptAll,
 	getMaterializedViewConfig,
 	getTableConfig,
 	getViewConfig,
 	inet,
 	integer,
+	intersect,
+	intersectAll,
 	jsonb,
 	macaddr,
 	macaddr8,
@@ -45,6 +49,8 @@ import {
 	serial,
 	text,
 	timestamp,
+	union,
+	unionAll,
 	unique,
 	uniqueKeyName,
 	uuid as pgUuid,
@@ -73,6 +79,11 @@ const citiesTable = pgTable('cities', {
 	state: char('state', { length: 2 }),
 });
 
+const cities2Table = pgTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
 const users2Table = pgTable('users2', {
 	id: serial('id').primaryKey(),
 	name: text('name').notNull(),
@@ -2465,7 +2476,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2475,17 +2486,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2497,11 +2508,845 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
+});
+
+test.serial('set operations (union) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: cities2Table.id, name: citiesTable.name })
+		.from(cities2Table).union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table),
+		).orderBy(asc(sql`name`));
+
+	t.assert(result.length === 11);
+
+	t.deepEqual(result, [
+		{ id: 5, name: 'Ben' },
+		{ id: 3, name: 'Jack' },
+		{ id: 2, name: 'Jane' },
+		{ id: 6, name: 'Jill' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'London' },
+		{ id: 7, name: 'Mary' },
+		{ id: 1, name: 'New York' },
+		{ id: 4, name: 'Peter' },
+		{ id: 8, name: 'Sally' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (union) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await union(
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	).orderBy(asc(sql`name`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'New York' },
+	]);
+});
+
+test.serial('set operations (union all) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: cities2Table.id, name: citiesTable.name })
+		.from(cities2Table).limit(2).unionAll(
+			db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table).limit(2),
+		).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 4);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 2, name: 'London' },
+	]);
+});
+
+test.serial('set operations (union all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await unionAll(
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 3);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('set operations (intersect) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: cities2Table.id, name: citiesTable.name })
+		.from(cities2Table).intersect(
+			db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table).where(gt(citiesTable.id, 1)),
+		).orderBy(asc(sql`name`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (intersect) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await intersect(
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 0);
+
+	t.deepEqual(result, []);
+});
+
+test.serial('set operations (intersect all) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: cities2Table.id, name: citiesTable.name })
+		.from(cities2Table).limit(2).intersectAll(
+			db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table).limit(2),
+		).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+	]);
+});
+
+test.serial('set operations (intersect all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await intersectAll(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 1);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('set operations (except) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(cities2Table).except(
+			db
+				.select()
+				.from(cities2Table).where(gt(citiesTable.id, 1)),
+		);
+
+	t.assert(result.length === 1);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+	]);
+});
+
+test.serial('set operations (except) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await except(
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table),
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (except all) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(cities2Table).exceptAll(
+			db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table).where(eq(citiesTable.id, 1)),
+		).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (except all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await exceptAll(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(gt(users2Table.id, 7)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 6);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'Jane' },
+		{ id: 3, name: 'Jack' },
+		{ id: 4, name: 'Peter' },
+		{ id: 5, name: 'Ben' },
+		{ id: 6, name: 'Jill' },
+		{ id: 7, name: 'Mary' },
+	]);
+});
+
+test.serial('set operations (mixed) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(cities2Table).except(
+			({ unionAll }) =>
+				unionAll(
+					db
+						.select()
+						.from(cities2Table).where(gt(citiesTable.id, 1)),
+					db.select().from(cities2Table).where(eq(citiesTable.id, 2)),
+				),
+		);
+
+	t.assert(result.length === 1);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+	]);
+});
+
+test.serial('set operations (mixed all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await union(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		except(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(gte(users2Table.id, 5)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 7)),
+		),
+		db
+			.select().from(cities2Table).where(gt(citiesTable.id, 1)),
+	).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 6);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+		{ id: 5, name: 'Ben' },
+		{ id: 6, name: 'Jill' },
+		{ id: 8, name: 'Sally' },
+	]);
 });

From 35a525de0e177a56d7b34ecbf2f97f43f5468450 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Thu, 21 Sep 2023 01:47:06 -0400
Subject: [PATCH 21/72] [SQLite] Completed implementation of set operators

 - added SQLiteSetOperatorBuilder and SQLiteSetOperator classes

 - SQLiteSelectBuilder now extends from SQLiteSetOperatorBuilder to inherit its methods

 - Exported funciton versions of union, unionAll, intersect and except

 - Had to add the last generic parameter as any to the in a type for libsql driver
---
 drizzle-orm/src/libsql/driver.ts              |   9 +-
 .../src/sqlite-core/query-builders/index.ts   |   1 +
 .../src/sqlite-core/query-builders/select.ts  |  13 +-
 .../query-builders/set-operators.ts           | 540 ++++++++++++++++++
 4 files changed, 552 insertions(+), 11 deletions(-)
 create mode 100644 drizzle-orm/src/sqlite-core/query-builders/set-operators.ts

diff --git a/drizzle-orm/src/libsql/driver.ts b/drizzle-orm/src/libsql/driver.ts
index 2f4bc5c58..9a9f33cf8 100644
--- a/drizzle-orm/src/libsql/driver.ts
+++ b/drizzle-orm/src/libsql/driver.ts
@@ -10,12 +10,7 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import type {
-	SQLiteDelete,
-	SQLiteInsert,
-	SQLiteSelect,
-	SQLiteUpdate,
-} from '~/sqlite-core/index.ts';
+import type { SQLiteDelete, SQLiteInsert, SQLiteSelect, SQLiteUpdate } from '~/sqlite-core/index.ts';
 import type { SQLiteRelationalQuery } from '~/sqlite-core/query-builders/query.ts';
 import type { SQLiteRaw } from '~/sqlite-core/query-builders/raw.ts';
 import { type DrizzleConfig } from '~/utils.ts';
@@ -23,7 +18,7 @@ import { LibSQLSession } from './session.ts';
 
 export type BatchParameters =
 	| SQLiteUpdate<any, 'async', ResultSet, any>
-	| SQLiteSelect<any, 'async', ResultSet, any, any>
+	| SQLiteSelect<any, 'async', ResultSet, any, any, any>
 	| SQLiteDelete<any, 'async', ResultSet, any>
 	| Omit<SQLiteDelete<any, 'async', ResultSet, any>, 'where'>
 	| Omit<SQLiteUpdate<any, 'async', ResultSet, any>, 'where'>
diff --git a/drizzle-orm/src/sqlite-core/query-builders/index.ts b/drizzle-orm/src/sqlite-core/query-builders/index.ts
index 16f0e1d4d..58d909c22 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/index.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/index.ts
@@ -3,4 +3,5 @@ export * from './insert.ts';
 export * from './query-builder.ts';
 export * from './select.ts';
 export * from './select.types.ts';
+export * from './set-operators.ts';
 export * from './update.ts';
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.ts b/drizzle-orm/src/sqlite-core/query-builders/select.ts
index 9baa3dcd4..d226c5366 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.ts
@@ -1,5 +1,4 @@
 import { entityKind, is } from '~/entity.ts';
-import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
 	GetSelectTableName,
@@ -36,6 +35,7 @@ import type {
 	SQLiteSelectHKTBase,
 	SQLiteSelectQueryBuilderHKT,
 } from './select.types.ts';
+import { SQLiteSetOperatorBuilder } from './set-operators.ts';
 
 type CreateSQLiteSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
@@ -128,9 +128,14 @@ export abstract class SQLiteSelectQueryBuilder<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> extends SQLiteSetOperatorBuilder<
+	THKT,
+	TTableName,
+	TResultType,
+	TRunResult,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap
 > {
 	static readonly [entityKind]: string = 'SQLiteSelectQueryBuilder';
 
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
new file mode 100644
index 000000000..cb14005b4
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -0,0 +1,540 @@
+import { entityKind, is } from '~/entity.ts';
+import {
+	orderSelectedFields,
+	type Placeholder,
+	type Query,
+	SelectionProxyHandler,
+	SQL,
+	sql,
+	type ValueOrArray,
+} from '~/index.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
+import type {
+	BuildSubquerySelection,
+	JoinNullability,
+	SelectMode,
+	SelectResult,
+} from '~/query-builders/select.types.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import { applyMixins, type PromiseOf, type ValidateShape } from '~/utils.ts';
+import { type ColumnsSelection } from '~/view.ts';
+import { SQLiteColumn } from '../columns/common.ts';
+import type { SQLiteDialect } from '../dialect.ts';
+import type { SQLiteSelectHKTBase } from './select.types.ts';
+
+type SetOperator = 'union' | 'intersect' | 'except';
+
+const getSQLiteSetOperators = () => {
+	return {
+		union,
+		unionAll,
+		intersect,
+		except,
+	};
+};
+
+type SQLiteSetOperators = ReturnType<typeof getSQLiteSetOperators>;
+
+type SetOperatorRightSelect<
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+> = TValue extends SQLiteSetOperatorBuilder<any, any, any, any, infer TSel, infer TMode, infer TNull> ? ValidateShape<
+		SelectResult<TSel, TMode, TNull>,
+		SelectResult<TSelection, TSelectMode, TNullabilityMap>,
+		TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	>
+	: TValue;
+
+type SetOperatorRestSelect<
+	TValue extends readonly TypedQueryBuilder<any, any[]>[],
+	Valid,
+> = TValue extends [infer First, ...infer Rest]
+	? First extends SQLiteSetOperatorBuilder<any, any, any, any, infer TSel, infer TMode, infer TNull>
+		? Rest extends TypedQueryBuilder<any, any[]>[] ? [
+				ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue[0]>,
+				...SetOperatorRestSelect<Rest, Valid>,
+			]
+		: ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue>
+	: never[]
+	: TValue;
+
+export abstract class SQLiteSetOperatorBuilder<
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends TypedQueryBuilder<
+	BuildSubquerySelection<TSelection, TNullabilityMap>,
+	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+> {
+	static readonly [entityKind]: string = 'SQLiteSetOperatorBuilder';
+
+	protected abstract joinsNotNullableMap: Record<string, boolean>;
+	protected abstract config: {
+		fields: Record<string, unknown>;
+		limit?: number | Placeholder;
+		orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+	};
+	/* @internal */
+	protected abstract readonly session: SQLiteSession<any, any, any, any> | undefined;
+	protected abstract dialect: SQLiteDialect;
+
+	/** @internal */
+	getSetOperatorConfig() {
+		return {
+			session: this.session,
+			dialect: this.dialect,
+			joinsNotNullableMap: this.joinsNotNullableMap,
+			fields: this.config.fields,
+		};
+	}
+	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
+
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'union',
+			false,
+			this,
+			rightSelectOrig,
+		);
+	}
+
+	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
+
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'union',
+			true,
+			this,
+			rightSelectOrig,
+		);
+	}
+
+	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
+
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'intersect',
+			false,
+			this,
+			rightSelectOrig,
+		);
+	}
+
+	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+		rightSelect:
+			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
+			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
+	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
+
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'except',
+			false,
+			this,
+			rightSelectOrig,
+		);
+	}
+
+	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
+	abstract orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): this;
+
+	abstract limit(limit: number): this;
+}
+
+export interface SQLiteSetOperator<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TResultType extends 'sync' | 'async',
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends
+	TypedQueryBuilder<
+		BuildSubquerySelection<TSelection, TNullabilityMap>,
+		SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+	>,
+	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+{}
+
+export class SQLiteSetOperator<
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+> extends SQLiteSetOperatorBuilder<
+	THKT,
+	TTableName,
+	TResultType,
+	TRunResult,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap
+> {
+	static readonly [entityKind]: string = 'SQLiteSetOperator';
+
+	protected joinsNotNullableMap: Record<string, boolean>;
+	protected config: {
+		fields: Record<string, unknown>;
+		limit?: number | Placeholder;
+		orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+	};
+	/* @internal */
+	readonly session: SQLiteSession<any, any, any, any> | undefined;
+	protected dialect: SQLiteDialect;
+
+	constructor(
+		private operator: SetOperator,
+		private isAll: boolean,
+		private leftSelect: SQLiteSetOperatorBuilder<
+			THKT,
+			TTableName,
+			TResultType,
+			TRunResult,
+			TSelection,
+			TSelectMode,
+			TNullabilityMap
+		>,
+		private rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	) {
+		super();
+
+		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
+		this.session = session;
+		this.dialect = dialect;
+		this.joinsNotNullableMap = joinsNotNullableMap;
+		this.config = {
+			fields,
+		};
+	}
+
+	orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
+	orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): this;
+	orderBy(
+		...columns:
+			| [(aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
+			| (SQLiteColumn | SQL | SQL.Aliased)[]
+	): this {
+		if (typeof columns[0] === 'function') {
+			const orderBy = columns[0](
+				new Proxy(
+					this.config.fields,
+					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
+				) as TSelection,
+			);
+			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+		} else {
+			this.config.orderBy = columns as (SQLiteColumn | SQL | SQL.Aliased)[];
+		}
+		return this;
+	}
+
+	limit(limit: number) {
+		this.config.limit = limit;
+		return this;
+	}
+
+	toSQL(): Query {
+		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+		return rest;
+	}
+
+	override getSQL(): SQL<unknown> {
+		const leftChunk = sql`${this.leftSelect.getSQL()} `;
+		const rightChunk = sql`${this.rightSelect.getSQL()}`;
+
+		let orderBySql;
+		if (this.config.orderBy && this.config.orderBy.length > 0) {
+			const orderByValues: SQL<unknown>[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const orderBy of this.config.orderBy) {
+				if (is(orderBy, SQLiteColumn)) {
+					orderByValues.push(sql.raw(orderBy.name));
+				} else if (is(orderBy, SQL)) {
+					for (let i = 0; i < orderBy.queryChunks.length; i++) {
+						const chunk = orderBy.queryChunks[i];
+
+						if (is(chunk, SQLiteColumn)) {
+							orderBy.queryChunks[i] = sql.raw(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${orderBy}`);
+				} else {
+					orderByValues.push(sql`${orderBy}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)}`;
+		}
+
+		const limitSql = this.config.limit ? sql` limit ${this.config.limit}` : undefined;
+
+		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}`;
+	}
+
+	prepare(isOneTimeQuery?: boolean): PreparedQuery<
+		{
+			type: TResultType;
+			run: TRunResult;
+			all: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+			get: SelectResult<TSelection, TSelectMode, TNullabilityMap> | undefined;
+			values: any[][];
+			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+		}
+	> {
+		if (!this.session) {
+			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
+		}
+		const fieldsList = orderSelectedFields<SQLiteColumn>(this.config.fields);
+		const query = this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
+			this.dialect.sqlToQuery(this.getSQL()),
+			fieldsList,
+			'all',
+		);
+		query.joinsNotNullableMap = this.joinsNotNullableMap;
+		return query as ReturnType<this['prepare']>;
+	}
+
+	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
+		return this.prepare(true).run(placeholderValues);
+	};
+
+	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
+		return this.prepare(true).all(placeholderValues);
+	};
+
+	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
+		return this.prepare(true).get(placeholderValues);
+	};
+
+	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
+		return this.prepare(true).values(placeholderValues);
+	};
+
+	async execute(): Promise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+		return this.all() as PromiseOf<ReturnType<this['execute']>>;
+	}
+}
+
+applyMixins(SQLiteSetOperator, [QueryPromise]);
+
+export function union<
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
+>(
+	leftSelect: SQLiteSetOperatorBuilder<
+		THKT,
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'union',
+			false,
+			leftSelect,
+			rightSelect,
+		);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return union(
+		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'union',
+			false,
+			leftSelect,
+			rightSelect,
+		),
+		select,
+		...rest,
+	);
+}
+
+export function unionAll<
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
+>(
+	leftSelect: SQLiteSetOperatorBuilder<
+		THKT,
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'union',
+			true,
+			leftSelect,
+			rightSelect,
+		);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return unionAll(
+		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'union',
+			true,
+			leftSelect,
+			rightSelect,
+		),
+		select,
+		...rest,
+	);
+}
+
+export function intersect<
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
+>(
+	leftSelect: SQLiteSetOperatorBuilder<
+		THKT,
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'intersect',
+			false,
+			leftSelect,
+			rightSelect,
+		);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return intersect(
+		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'intersect',
+			false,
+			leftSelect,
+			rightSelect!,
+		),
+		select,
+		...rest,
+	);
+}
+
+export function except<
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
+>(
+	leftSelect: SQLiteSetOperatorBuilder<
+		THKT,
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
+	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
+): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+	if (restSelects.length === 0) {
+		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'except',
+			false,
+			leftSelect,
+			rightSelect,
+		);
+	}
+
+	const [select, ...rest] = restSelects;
+	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+
+	return except(
+		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			'except',
+			false,
+			leftSelect,
+			rightSelect!,
+		),
+		select,
+		...rest,
+	);
+}

From e555c093f4e4e990d870167cbebf7be960b9eca7 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Thu, 21 Sep 2023 01:47:49 -0400
Subject: [PATCH 22/72] [SQLite] Added type tests

---
 .../type-tests/sqlite/set-operators.ts        | 194 ++++++++++++++++++
 1 file changed, 194 insertions(+)
 create mode 100644 drizzle-orm/type-tests/sqlite/set-operators.ts

diff --git a/drizzle-orm/type-tests/sqlite/set-operators.ts b/drizzle-orm/type-tests/sqlite/set-operators.ts
new file mode 100644
index 000000000..c37c857d7
--- /dev/null
+++ b/drizzle-orm/type-tests/sqlite/set-operators.ts
@@ -0,0 +1,194 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import { eq } from '~/expressions.ts';
+import { desc, sql } from '~/sql/index.ts';
+import { except, intersect, union, unionAll } from '~/sqlite-core/index.ts';
+import { db } from './db.ts';
+import { cities, classes, newYorkers, users } from './tables.ts';
+
+const unionTest = await db
+	.select({ id: users.id })
+	.from(users)
+	.union(
+		db
+			.select({ id: users.id })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number }[], typeof unionTest>>;
+
+const unionAllTest = await db
+	.select({ id: users.id, text: users.name })
+	.from(users)
+	.unionAll(
+		db.select({ id: users.id, text: users.name })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; text: string | null }[], typeof unionAllTest>>;
+
+const intersectTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.intersect(({ intersect }) =>
+		intersect(
+			db
+				.select({ id: users.id, homeCity: users.homeCity })
+				.from(users),
+			db
+				.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+				.from(users),
+		)
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
+
+const intersectAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.intersect(
+		db
+			.select({ id: users.id, homeCity: users.class })
+			.from(users)
+			.leftJoin(cities, eq(users.id, cities.id)),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof intersectAllTest>>;
+
+const exceptTest = await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql`${users.homeCity}`.mapWith(Number) })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
+
+const exceptAllTest = await db
+	.select({ id: users.id, homeCity: users.class })
+	.from(users)
+	.except(
+		db
+			.select({ id: users.id, homeCity: sql<'A' | 'C'>`${users.class}` })
+			.from(users),
+	);
+
+Expect<Equal<{ id: number; homeCity: 'A' | 'C' }[], typeof exceptAllTest>>;
+
+const union2Test = await union(db.select().from(cities), db.select().from(cities), db.select().from(cities));
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof union2Test>>;
+
+const unionAll2Test = await unionAll(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select().from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof unionAll2Test>>;
+
+const intersect2Test = await intersect(
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+		name: cities.name,
+		population: cities.population,
+	}).from(cities),
+);
+
+Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
+
+const intersectAll2Test = await intersect(
+	db.select({
+		id: cities.id,
+	}).from(cities),
+	db.select({
+		id: cities.id,
+	})
+		.from(cities),
+).orderBy(desc(cities.id)).limit(23);
+
+Expect<Equal<{ id: number }[], typeof intersectAll2Test>>;
+
+const except2Test = await except(
+	db.select({
+		userId: newYorkers.userId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number }[], typeof except2Test>>;
+
+const exceptAll2Test = await except(
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	})
+		.from(newYorkers),
+	db.select({
+		userId: newYorkers.userId,
+		cityId: newYorkers.cityId,
+	}).from(newYorkers),
+);
+
+Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
+
+// @ts-expect-error - The select on both sites must be the same shape
+db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
+
+// @ts-expect-error - The select on both sites must be the same shape
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
+
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	// @ts-expect-error - The select on rest parameter must be the same shape
+	db.select().from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+);
+
+union(
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	db.select({ id: sql<number>`${cities.id}` }).from(cities),
+	db.select({ id: cities.id }).from(cities),
+	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+);

From 14f996be3d0a0ecbe02db253c03f3858677bf606 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Thu, 21 Sep 2023 01:48:12 -0400
Subject: [PATCH 23/72] [SQLite] Added integration tests for all cases

---
 integration-tests/tests/libsql.test.ts | 613 ++++++++++++++++++++++++-
 1 file changed, 607 insertions(+), 6 deletions(-)

diff --git a/integration-tests/tests/libsql.test.ts b/integration-tests/tests/libsql.test.ts
index 575f20c75..5229eb574 100644
--- a/integration-tests/tests/libsql.test.ts
+++ b/integration-tests/tests/libsql.test.ts
@@ -7,6 +7,7 @@ import {
 	asc,
 	eq,
 	gt,
+	gte,
 	inArray,
 	type InferModel,
 	Name,
@@ -20,13 +21,17 @@ import { migrate } from 'drizzle-orm/libsql/migrator';
 import {
 	alias,
 	blob,
+	except,
 	getViewConfig,
 	integer,
+	intersect,
 	primaryKey,
 	sqliteTable,
 	sqliteTableCreator,
 	sqliteView,
 	text,
+	union,
+	unionAll,
 } from 'drizzle-orm/sqlite-core';
 import { type Equal, Expect } from './utils.ts';
 
@@ -1756,16 +1761,16 @@ test.serial('insert with onConflict do update where', async (t) => {
 
 	await db
 		.insert(usersTable)
-		.values([{ id: 1, name: "John", verified: false }])
+		.values([{ id: 1, name: 'John', verified: false }])
 		.run();
 
 	await db
 		.insert(usersTable)
-		.values({ id: 1, name: "John1", verified: true })
+		.values({ id: 1, name: 'John1', verified: true })
 		.onConflictDoUpdate({
 			target: usersTable.id,
-			set: { name: "John1", verified: true },
-			where: eq(usersTable.verified, false)
+			set: { name: 'John1', verified: true },
+			where: eq(usersTable.verified, false),
 		})
 		.run();
 
@@ -1775,8 +1780,8 @@ test.serial('insert with onConflict do update where', async (t) => {
 		.where(eq(usersTable.id, 1))
 		.all();
 
-	t.deepEqual(res, [{ id: 1, name: "John1", verified: true }]);
-})
+	t.deepEqual(res, [{ id: 1, name: 'John1', verified: true }]);
+});
 
 test.serial('insert with onConflict do update using composite pk', async (t) => {
 	const { db } = t.context;
@@ -1970,3 +1975,599 @@ test.serial('select + .get() for empty result', async (t) => {
 
 	await db.run(sql`drop table ${users}`);
 });
+
+test.serial('set operations (union) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(sql`
+		create table \`cities\` (
+			id integer primary key,
+			name text not null
+		)
+	`);
+
+	await db.run(sql`
+		create table \`users2\` (
+			id integer primary key,
+			name text not null,
+			city_id integer references ${citiesTable}(${name(citiesTable.id.name)})
+		)
+	`);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable).union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table),
+		).orderBy(asc(sql`name`));
+
+	t.assert(result.length === 11);
+
+	t.deepEqual(result, [
+		{ id: 5, name: 'Ben' },
+		{ id: 3, name: 'Jack' },
+		{ id: 2, name: 'Jane' },
+		{ id: 6, name: 'Jill' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'London' },
+		{ id: 7, name: 'Mary' },
+		{ id: 1, name: 'New York' },
+		{ id: 4, name: 'Peter' },
+		{ id: 8, name: 'Sally' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (union) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(sql`
+		create table \`cities\` (
+			id integer primary key,
+			name text not null
+		)
+	`);
+
+	await db.run(sql`
+		create table \`users2\` (
+			id integer primary key,
+			name text not null,
+			city_id integer references ${citiesTable}(${name(citiesTable.id.name)})
+		)
+	`);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await union(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	).orderBy(asc(sql`name`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'New York' },
+	]);
+});
+
+test.serial('set operations (union all) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table users2 (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable).unionAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable),
+		).orderBy(asc(citiesTable.id));
+
+	t.assert(result.length === 6);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (union all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table users2 (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await unionAll(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 3);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('set operations (intersect) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table users2 (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name })
+		.from(citiesTable).intersect(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(gt(citiesTable.id, 1)),
+		).orderBy(asc(sql`name`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (intersect) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table users2 (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await intersect(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	);
+
+	t.assert(result.length === 0);
+
+	t.deepEqual(result, []);
+});
+
+test.serial('set operations (except) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table users2 (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(citiesTable).except(
+			db
+				.select()
+				.from(citiesTable).where(gt(citiesTable.id, 1)),
+		);
+
+	t.assert(result.length === 1);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+	]);
+});
+
+test.serial('set operations (except) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table users2 (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await except(
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable),
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).where(eq(citiesTable.id, 1)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+	).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+});
+
+test.serial('set operations (mixed) from query builder', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table users2 (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await db
+		.select()
+		.from(citiesTable).except(
+			({ unionAll }) =>
+				unionAll(
+					db
+						.select()
+						.from(citiesTable).where(gt(citiesTable.id, 1)),
+					db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+				),
+		);
+
+	t.assert(result.length === 2);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+	]);
+});
+
+test.serial('set operations (mixed all) as function', async (t) => {
+	const { db } = t.context;
+
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(
+		sql`
+			create table \`cities\` (
+			  id integer primary key,
+			  name text not null
+			)
+		`,
+	);
+	await db.run(
+		sql`
+			create table \`users2\` (
+			  id integer primary key,
+			  name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+
+	const result = await union(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 1)),
+		except(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(gte(users2Table.id, 5)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 7)),
+		),
+		db
+			.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+	).orderBy(asc(sql`id`));
+
+	t.assert(result.length === 6);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+		{ id: 5, name: 'Ben' },
+		{ id: 6, name: 'Jill' },
+		{ id: 8, name: 'Sally' },
+	]);
+});

From 90484020c68e8a0ab88de03267ee18c38185ccc2 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Thu, 21 Sep 2023 22:18:44 +0300
Subject: [PATCH 24/72] Add custom names for primaryKey and foreignKey
 constraints defined in drizzle schema

---
 drizzle-orm/src/mysql-core/primary-keys.ts  |  5 +--
 drizzle-orm/src/pg-core/foreign-keys.ts     |  4 ++-
 drizzle-orm/src/pg-core/primary-keys.ts     |  5 +--
 drizzle-orm/src/sqlite-core/foreign-keys.ts | 34 +++++++++++++++++---
 drizzle-orm/src/sqlite-core/primary-keys.ts |  5 +--
 integration-tests/tests/libsql.test.ts      | 35 +++++++++++++++++++++
 integration-tests/tests/mysql.test.ts       |  8 ++---
 integration-tests/tests/pg.test.ts          | 32 +++++++++++++++++++
 8 files changed, 112 insertions(+), 16 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/primary-keys.ts b/drizzle-orm/src/mysql-core/primary-keys.ts
index bb7e83a64..cb43e8351 100644
--- a/drizzle-orm/src/mysql-core/primary-keys.ts
+++ b/drizzle-orm/src/mysql-core/primary-keys.ts
@@ -4,8 +4,9 @@ import { MySqlTable } from './table.ts';
 
 export function primaryKey<
 	TTableName extends string,
-	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>,
->(config: { name?: string; columns: [TColumns, ...TColumns[]] }): PrimaryKeyBuilder;
+	TColumn extends AnyMySqlColumn<{ tableName: TTableName }>,
+	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>[],
+>(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
 /**
  * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
  * @param columns
diff --git a/drizzle-orm/src/pg-core/foreign-keys.ts b/drizzle-orm/src/pg-core/foreign-keys.ts
index e7864bd71..42238666d 100644
--- a/drizzle-orm/src/pg-core/foreign-keys.ts
+++ b/drizzle-orm/src/pg-core/foreign-keys.ts
@@ -100,13 +100,15 @@ export function foreignKey<
 	TColumns extends [AnyPgColumn<{ tableName: TTableName }>, ...AnyPgColumn<{ tableName: TTableName }>[]],
 >(
 	config: {
+		name?: string;
 		columns: TColumns;
 		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
 	},
 ): ForeignKeyBuilder {
 	function mappedConfig() {
-		const { columns, foreignColumns } = config;
+		const { name, columns, foreignColumns } = config;
 		return {
+			name,
 			columns,
 			foreignColumns,
 		};
diff --git a/drizzle-orm/src/pg-core/primary-keys.ts b/drizzle-orm/src/pg-core/primary-keys.ts
index 266f55e2f..b9364c6ef 100644
--- a/drizzle-orm/src/pg-core/primary-keys.ts
+++ b/drizzle-orm/src/pg-core/primary-keys.ts
@@ -4,8 +4,9 @@ import { PgTable } from './table.ts';
 
 export function primaryKey<
 	TTableName extends string,
-	TColumns extends AnyPgColumn<{ tableName: TTableName }>,
->(config: { name?: string; columns: [TColumns, ...TColumns[]] }): PrimaryKeyBuilder;
+	TColumn extends AnyPgColumn<{ tableName: TTableName }>,
+	TColumns extends AnyPgColumn<{ tableName: TTableName }>[],
+>(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
 /**
  * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
  * @param columns 
diff --git a/drizzle-orm/src/sqlite-core/foreign-keys.ts b/drizzle-orm/src/sqlite-core/foreign-keys.ts
index 76a8a529c..9cc14072f 100644
--- a/drizzle-orm/src/sqlite-core/foreign-keys.ts
+++ b/drizzle-orm/src/sqlite-core/foreign-keys.ts
@@ -97,22 +97,46 @@ type ColumnsWithTable<
 	TColumns extends SQLiteColumn[],
 > = { [Key in keyof TColumns]: AnySQLiteColumn<{ tableName: TTableName }> };
 
+/**
+ * @deprecated please use `foreignKey({ columns: [], foreignColumns: [] })` syntax without callback
+ * @param config
+ * @returns
+ */
 export function foreignKey<
 	TTableName extends string,
 	TForeignTableName extends string,
 	TColumns extends [AnySQLiteColumn<{ tableName: TTableName }>, ...AnySQLiteColumn<{ tableName: TTableName }>[]],
 >(
 	config: () => {
+		name?: string;
 		columns: TColumns;
 		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
 	},
+): ForeignKeyBuilder;
+export function foreignKey<
+	TTableName extends string,
+	TForeignTableName extends string,
+	TColumns extends [AnySQLiteColumn<{ tableName: TTableName }>, ...AnySQLiteColumn<{ tableName: TTableName }>[]],
+>(
+	config: {
+		name?: string;
+		columns: TColumns;
+		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
+	},
+): ForeignKeyBuilder;
+export function foreignKey(
+	config: any,
 ): ForeignKeyBuilder {
 	function mappedConfig() {
-		const { columns, foreignColumns } = config();
-		return {
-			columns,
-			foreignColumns,
-		};
+		if (typeof config === 'function') {
+			const { name, columns, foreignColumns } = config();
+			return {
+				name,
+				columns,
+				foreignColumns,
+			};
+		}
+		return config;
 	}
 
 	return new ForeignKeyBuilder(mappedConfig);
diff --git a/drizzle-orm/src/sqlite-core/primary-keys.ts b/drizzle-orm/src/sqlite-core/primary-keys.ts
index ee132f8e5..1d73d6461 100644
--- a/drizzle-orm/src/sqlite-core/primary-keys.ts
+++ b/drizzle-orm/src/sqlite-core/primary-keys.ts
@@ -4,8 +4,9 @@ import { SQLiteTable } from './table.ts';
 
 export function primaryKey<
 	TTableName extends string,
-	TColumns extends AnySQLiteColumn<{ tableName: TTableName }>,
->(config: { name?: string; columns: [TColumns, ...TColumns[]] }): PrimaryKeyBuilder;
+	TColumn extends AnySQLiteColumn<{ tableName: TTableName }>,
+	TColumns extends AnySQLiteColumn<{ tableName: TTableName }>[],
+>(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
 /**
  * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
  * @param columns
diff --git a/integration-tests/tests/libsql.test.ts b/integration-tests/tests/libsql.test.ts
index 575f20c75..14e244a9e 100644
--- a/integration-tests/tests/libsql.test.ts
+++ b/integration-tests/tests/libsql.test.ts
@@ -20,7 +20,10 @@ import { migrate } from 'drizzle-orm/libsql/migrator';
 import {
 	alias,
 	blob,
+	foreignKey,
+	getTableConfig,
 	getViewConfig,
+	int,
 	integer,
 	primaryKey,
 	sqliteTable,
@@ -211,6 +214,38 @@ test.beforeEach(async (t) => {
 	`);
 });
 
+test.serial('table config: foreign keys name', async (t) => {
+	const table = sqliteTable('cities', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
+		f1: foreignKey(() => ({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk_deprecated' })),
+	}));
+
+	const tableConfig = getTableConfig(table);
+
+	t.is(tableConfig.foreignKeys.length, 2);
+	t.is(tableConfig.foreignKeys[0]!.getName(), 'custom_fk');
+	t.is(tableConfig.foreignKeys[1]!.getName(), 'custom_fk_deprecated');
+});
+
+test.serial('table config: primary keys name', async (t) => {
+	const table = sqliteTable('cities', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
+	}));
+
+	const tableConfig = getTableConfig(table);
+
+	t.is(tableConfig.primaryKeys.length, 1);
+	t.is(tableConfig.primaryKeys[0]!.getName(), 'custom_pk');
+});
+
 test.serial('insert bigint values', async (t) => {
 	const { db } = t.context;
 
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index 373c953e4..914eb68a5 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -221,7 +221,7 @@ test.beforeEach(async (t) => {
 	);
 });
 
-test.serial.only('table config: unsigned ints', async (t) => {
+test.serial('table config: unsigned ints', async (t) => {
 	const unsignedInts = mysqlTable('cities1', {
 		bigint: bigint('bigint', { mode: 'number', unsigned: true }),
 		int: int('int', { unsigned: true }),
@@ -245,7 +245,7 @@ test.serial.only('table config: unsigned ints', async (t) => {
 	t.is(tinyintColumn.getSQLType(), 'tinyint unsigned');
 });
 
-test.serial.only('table config: signed ints', async (t) => {
+test.serial('table config: signed ints', async (t) => {
 	const unsignedInts = mysqlTable('cities1', {
 		bigint: bigint('bigint', { mode: 'number' }),
 		int: int('int'),
@@ -269,7 +269,7 @@ test.serial.only('table config: signed ints', async (t) => {
 	t.is(tinyintColumn.getSQLType(), 'tinyint');
 });
 
-test.serial.only('table config: foreign keys name', async (t) => {
+test.serial('table config: foreign keys name', async (t) => {
 	const table = mysqlTable('cities', {
 		id: serial('id').primaryKey(),
 		name: text('name').notNull(),
@@ -284,7 +284,7 @@ test.serial.only('table config: foreign keys name', async (t) => {
 	t.is(tableConfig.foreignKeys[0]!.getName(), 'custom_fk');
 });
 
-test.serial.only('table config: primary keys name', async (t) => {
+test.serial('table config: primary keys name', async (t) => {
 	const table = mysqlTable('cities', {
 		id: serial('id').primaryKey(),
 		name: text('name').notNull(),
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index b2135112b..10d2ba609 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -49,6 +49,8 @@ import {
 	uniqueKeyName,
 	uuid as pgUuid,
 	varchar,
+	primaryKey,
+	foreignKey,
 } from 'drizzle-orm/pg-core';
 import getPort from 'get-port';
 import pg from 'pg';
@@ -328,6 +330,36 @@ test.serial('table configs: unique in column', async (t) => {
 	t.assert(columnField?.uniqueType === 'not distinct');
 });
 
+test.serial('table config: foreign keys name', async (t) => {
+	const table = pgTable('cities', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: foreignKey({ foreignColumns: [t.id], columns: [t.id], name: 'custom_fk' }),
+	}));
+
+	const tableConfig = getTableConfig(table);
+
+	t.is(tableConfig.foreignKeys.length, 1);
+	t.is(tableConfig.foreignKeys[0]!.getName(), 'custom_fk');
+});
+
+test.serial('table config: primary keys name', async (t) => {
+	const table = pgTable('cities', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: primaryKey({ columns: [t.id, t.name], name: 'custom_pk' }),
+	}));
+
+	const tableConfig = getTableConfig(table);
+
+	t.is(tableConfig.primaryKeys.length, 1);
+	t.is(tableConfig.primaryKeys[0]!.getName(), 'custom_pk');
+});
+
 test.serial('select all fields', async (t) => {
 	const { db } = t.context;
 

From 8808a1f05a0cbb9e17943098b9b4bb557f2c6353 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Fri, 22 Sep 2023 21:03:20 -0400
Subject: [PATCH 25/72] [All] Completed implementation with requested changes

 - Added coments for type tests

 - Added runtime check that throws an error if the select have keys in different order

 - Added tests for the new error throwing behavior
---
 .../query-builders/set-operators.ts           |  16 +
 .../pg-core/query-builders/set-operators.ts   |  16 +-
 .../query-builders/set-operators.ts           |  16 +-
 drizzle-orm/src/utils.ts                      |  17 +
 drizzle-orm/type-tests/mysql/set-operators.ts |  24 +-
 drizzle-orm/type-tests/pg/set-operators.ts    |  24 +-
 .../type-tests/sqlite/set-operators.ts        |  24 +-
 integration-tests/tests/libsql.test.ts        | 530 +++++--------
 integration-tests/tests/mysql.test.ts         | 739 ++++++------------
 integration-tests/tests/pg.test.ts            | 735 ++++++-----------
 10 files changed, 745 insertions(+), 1396 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index f0af2b79a..5c7c3cf0a 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -1,6 +1,7 @@
 import { entityKind, is } from '~/entity.ts';
 import {
 	applyMixins,
+	haveSameKeys,
 	orderSelectedFields,
 	type Placeholder,
 	type Query,
@@ -221,7 +222,22 @@ export class MySqlSetOperator<
 		private rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
 		super();
+
+		const leftSelectedFields = leftSelect.getSelectedFields();
+		const rightSelectedFields = rightSelect.getSelectedFields();
+
+		if (!haveSameKeys(leftSelectedFields, rightSelectedFields)) {
+			throw new Error(
+				'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+			);
+		}
+
 		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
+
+		this._ = {
+			selectedFields: fields,
+		} as this['_'];
+
 		this.session = session;
 		this.dialect = dialect;
 		this.joinsNotNullableMap = joinsNotNullableMap;
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index 05af888e1..03293cbf9 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -18,7 +18,7 @@ import type {
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import { tracer } from '~/tracing.ts';
-import { applyMixins, type ValidateShape } from '~/utils.ts';
+import { applyMixins, haveSameKeys, type ValidateShape } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { PgColumn } from '../columns/common.ts';
 import type { PgDialect } from '../dialect.ts';
@@ -213,7 +213,21 @@ export class PgSetOperator<
 	) {
 		super();
 
+		const leftSelectedFields = leftSelect.getSelectedFields();
+		const rightSelectedFields = rightSelect.getSelectedFields();
+
+		if (!haveSameKeys(leftSelectedFields, rightSelectedFields)) {
+			throw new Error(
+				'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+			);
+		}
+
 		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
+
+		this._ = {
+			selectedFields: fields as BuildSubquerySelection<TSelection, TNullabilityMap>,
+		} as this['_'];
+
 		this.session = session;
 		this.dialect = dialect;
 		this.joinsNotNullableMap = joinsNotNullableMap;
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index cb14005b4..635249786 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -17,7 +17,7 @@ import type {
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
-import { applyMixins, type PromiseOf, type ValidateShape } from '~/utils.ts';
+import { applyMixins, haveSameKeys, type PromiseOf, type ValidateShape } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { SQLiteColumn } from '../columns/common.ts';
 import type { SQLiteDialect } from '../dialect.ts';
@@ -227,7 +227,21 @@ export class SQLiteSetOperator<
 	) {
 		super();
 
+		const leftSelectedFields = leftSelect.getSelectedFields();
+		const rightSelectedFields = rightSelect.getSelectedFields();
+
+		if (!haveSameKeys(leftSelectedFields, rightSelectedFields)) {
+			throw new Error(
+				'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+			);
+		}
+
 		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
+
+		this._ = {
+			selectedFields: fields as BuildSubquerySelection<TSelection, TNullabilityMap>,
+		} as this['_'];
+
 		this.session = session;
 		this.dialect = dialect;
 		this.joinsNotNullableMap = joinsNotNullableMap;
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index 713d88c84..4a1d40939 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -91,6 +91,23 @@ export function orderSelectedFields<TColumn extends AnyColumn>(
 	}, []) as SelectedFieldsOrdered<TColumn>;
 }
 
+export function haveSameKeys(left: Record<string, unknown>, right: Record<string, unknown>) {
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+
+	if (leftKeys.length !== rightKeys.length) {
+		return false;
+	}
+
+	for (let i = 0; i < leftKeys.length; i++) {
+		if (leftKeys[i] !== rightKeys[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
 /** @internal */
 export function mapUpdateSet(table: Table, values: Record<string, unknown>): UpdateSet {
 	const entries: [string, UpdateSet[string]][] = Object.entries(values)
diff --git a/drizzle-orm/type-tests/mysql/set-operators.ts b/drizzle-orm/type-tests/mysql/set-operators.ts
index 547d6cea6..bc869bf88 100644
--- a/drizzle-orm/type-tests/mysql/set-operators.ts
+++ b/drizzle-orm/type-tests/mysql/set-operators.ts
@@ -165,16 +165,22 @@ Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>
 	}
 }
 
-// @ts-expect-error - The select on both sites must be the same shape
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
 db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
 
-// @ts-expect-error - The select on both sites must be the same shape
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
 db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
 
 union(
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id, name: cities.name }).from(cities),
-	// @ts-expect-error - The select on rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select().from(cities),
 );
 
@@ -182,7 +188,9 @@ union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -191,7 +199,9 @@ union(
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -204,6 +214,8 @@ union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: sql<number>`${cities.id}` }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
 );
diff --git a/drizzle-orm/type-tests/pg/set-operators.ts b/drizzle-orm/type-tests/pg/set-operators.ts
index 06c1c9bef..4394fa43d 100644
--- a/drizzle-orm/type-tests/pg/set-operators.ts
+++ b/drizzle-orm/type-tests/pg/set-operators.ts
@@ -150,16 +150,22 @@ const exceptAll2Test = await exceptAll(
 
 Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
 
-// @ts-expect-error - The select on both sites must be the same shape
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
 db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
 
-// @ts-expect-error - The select on both sites must be the same shape
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
 db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
 
 union(
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id, name: cities.name }).from(cities),
-	// @ts-expect-error - The select on rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select().from(cities),
 );
 
@@ -167,7 +173,9 @@ union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -176,7 +184,9 @@ union(
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -189,6 +199,8 @@ union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: sql<number>`${cities.id}` }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
 );
diff --git a/drizzle-orm/type-tests/sqlite/set-operators.ts b/drizzle-orm/type-tests/sqlite/set-operators.ts
index c37c857d7..ed98dac9e 100644
--- a/drizzle-orm/type-tests/sqlite/set-operators.ts
+++ b/drizzle-orm/type-tests/sqlite/set-operators.ts
@@ -150,16 +150,22 @@ const exceptAll2Test = await except(
 
 Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
 
-// @ts-expect-error - The select on both sites must be the same shape
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
 db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
 
-// @ts-expect-error - The select on both sites must be the same shape
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
 db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
 
 union(
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id, name: cities.name }).from(cities),
-	// @ts-expect-error - The select on rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select().from(cities),
 );
 
@@ -167,7 +173,9 @@ union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -176,7 +184,9 @@ union(
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -189,6 +199,8 @@ union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: sql<number>`${cities.id}` }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	// @ts-expect-error - The select on any part of the rest parameter must be the same shape
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
 );
diff --git a/integration-tests/tests/libsql.test.ts b/integration-tests/tests/libsql.test.ts
index 5229eb574..1414a96ce 100644
--- a/integration-tests/tests/libsql.test.ts
+++ b/integration-tests/tests/libsql.test.ts
@@ -216,6 +216,42 @@ test.beforeEach(async (t) => {
 	`);
 });
 
+async function setupSetOperationTest(db: LibSQLDatabase<Record<string, never>>) {
+	await db.run(sql`drop table if exists users2`);
+	await db.run(sql`drop table if exists cities`);
+	await db.run(sql`
+		create table \`cities\` (
+			id integer primary key,
+			name text not null
+		)
+	`);
+
+	await db.run(sql`
+		create table \`users2\` (
+			id integer primary key,
+			name text not null,
+			city_id integer references ${citiesTable}(${name(citiesTable.id.name)})
+		)
+	`);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+}
+
 test.serial('insert bigint values', async (t) => {
 	const { db } = t.context;
 
@@ -1979,39 +2015,7 @@ test.serial('select + .get() for empty result', async (t) => {
 test.serial('set operations (union) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(sql`
-		create table \`cities\` (
-			id integer primary key,
-			name text not null
-		)
-	`);
-
-	await db.run(sql`
-		create table \`users2\` (
-			id integer primary key,
-			name text not null,
-			city_id integer references ${citiesTable}(${name(citiesTable.id.name)})
-		)
-	`);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
@@ -2036,44 +2040,22 @@ test.serial('set operations (union) from query builder', async (t) => {
 		{ id: 8, name: 'Sally' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ name: citiesTable.name, id: citiesTable.id })
+			.from(citiesTable).union(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table),
+			).orderBy(asc(sql`name`));
+	});
 });
 
 test.serial('set operations (union) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(sql`
-		create table \`cities\` (
-			id integer primary key,
-			name text not null
-		)
-	`);
-
-	await db.run(sql`
-		create table \`users2\` (
-			id integer primary key,
-			name text not null,
-			city_id integer references ${citiesTable}(${name(citiesTable.id.name)})
-		)
-	`);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await union(
 		db
@@ -2093,47 +2075,26 @@ test.serial('set operations (union) as function', async (t) => {
 		{ id: 1, name: 'John' },
 		{ id: 1, name: 'New York' },
 	]);
+
+	t.throws(() => {
+		union(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).orderBy(asc(sql`name`));
+	});
 });
 
 test.serial('set operations (union all) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table users2 (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
@@ -2153,47 +2114,22 @@ test.serial('set operations (union all) from query builder', async (t) => {
 		{ id: 3, name: 'Tampa' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).unionAll(
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable),
+			).orderBy(asc(citiesTable.id));
+	});
 });
 
 test.serial('set operations (union all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table users2 (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await unionAll(
 		db
@@ -2214,47 +2150,26 @@ test.serial('set operations (union all) as function', async (t) => {
 		{ id: 1, name: 'John' },
 		{ id: 1, name: 'John' },
 	]);
+
+	t.throws(() => {
+		unionAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (intersect) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table users2 (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
@@ -2270,47 +2185,22 @@ test.serial('set operations (intersect) from query builder', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ name: citiesTable.name, id: citiesTable.id })
+			.from(citiesTable).intersect(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			).orderBy(asc(sql`name`));
+	});
 });
 
 test.serial('set operations (intersect) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table users2 (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await intersect(
 		db
@@ -2327,47 +2217,26 @@ test.serial('set operations (intersect) as function', async (t) => {
 	t.assert(result.length === 0);
 
 	t.deepEqual(result, []);
+
+	t.throws(() => {
+		intersect(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (except) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table users2 (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -2382,47 +2251,22 @@ test.serial('set operations (except) from query builder', async (t) => {
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
 	]);
+
+	t.throws(() => {
+		db
+			.select()
+			.from(citiesTable).except(
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			);
+	});
 });
 
 test.serial('set operations (except) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table users2 (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await except(
 		db
@@ -2442,47 +2286,26 @@ test.serial('set operations (except) as function', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		except(
+			db
+				.select({ name: citiesTable.name, id: citiesTable.id })
+				.from(citiesTable),
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (mixed) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table users2 (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -2502,47 +2325,27 @@ test.serial('set operations (mixed) from query builder', async (t) => {
 		{ id: 1, name: 'New York' },
 		{ id: 2, name: 'London' },
 	]);
+
+	t.throws(() => {
+		db
+			.select()
+			.from(citiesTable).except(
+				({ unionAll }) =>
+					unionAll(
+						db
+							.select()
+							.from(citiesTable).where(gt(citiesTable.id, 1)),
+						db.select({ name: citiesTable.name, id: citiesTable.id })
+							.from(citiesTable).where(eq(citiesTable.id, 2)),
+					),
+			);
+	});
 });
 
 test.serial('set operations (mixed all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.run(sql`drop table if exists users2`);
-	await db.run(sql`drop table if exists cities`);
-	await db.run(
-		sql`
-			create table \`cities\` (
-			  id integer primary key,
-			  name text not null
-			)
-		`,
-	);
-	await db.run(
-		sql`
-			create table \`users2\` (
-			  id integer primary key,
-			  name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await union(
 		db
@@ -2570,4 +2373,23 @@ test.serial('set operations (mixed all) as function', async (t) => {
 		{ id: 6, name: 'Jill' },
 		{ id: 8, name: 'Sally' },
 	]);
+
+	t.throws(() => {
+		union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			except(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(gte(users2Table.id, 5)),
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(eq(users2Table.id, 7)),
+			),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(citiesTable).where(gt(citiesTable.id, 1)),
+		).orderBy(asc(sql`id`));
+	});
 });
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index 9032f2108..f25a55328 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -222,6 +222,46 @@ test.beforeEach(async (t) => {
 	);
 });
 
+async function setupSetOperationTest(db: MySql2Database) {
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.insert(citiesTable).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+}
+
 test.serial('table configs: unique third param', async (t) => {
 	const cities1Table = mysqlTable('cities1', {
 		id: serial('id').primaryKey(),
@@ -2027,43 +2067,7 @@ test.serial('utc config for datetime', async (t) => {
 test.serial('set operations (union) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
@@ -2088,48 +2092,23 @@ test.serial('set operations (union) from query builder', async (t) => {
 		{ id: 7, name: 'Mary' },
 		{ id: 8, name: 'Sally' },
 	]);
-});
-
-test.serial('set operations (union) as function', async (t) => {
-	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
+	// union should throw if selected fields are not in the same order
+	t.throws(() =>
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).union(
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table),
 			)
-		`,
 	);
+});
 
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
+test.serial('set operations (union) as function', async (t) => {
+	const { db } = t.context;
 
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await union(
 		db
@@ -2149,48 +2128,26 @@ test.serial('set operations (union) as function', async (t) => {
 		{ id: 1, name: 'New York' },
 		{ id: 1, name: 'John' },
 	]);
+
+	t.throws(() => {
+		union(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (union all) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
@@ -2208,48 +2165,22 @@ test.serial('set operations (union all) from query builder', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 2, name: 'London' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).limit(2).unionAll(
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable).limit(2),
+			).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (union all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await unionAll(
 		db
@@ -2270,48 +2201,26 @@ test.serial('set operations (union all) as function', async (t) => {
 		{ id: 1, name: 'John' },
 		{ id: 1, name: 'John' },
 	]);
+
+	t.throws(() => {
+		unionAll(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (intersect) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
@@ -2327,48 +2236,22 @@ test.serial('set operations (intersect) from query builder', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ name: citiesTable.name, id: citiesTable.id })
+			.from(citiesTable).intersect(
+				db
+					.select({ id: citiesTable.id, name: citiesTable.name })
+					.from(citiesTable).where(gt(citiesTable.id, 1)),
+			);
+	});
 });
 
 test.serial('set operations (intersect) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await intersect(
 		db
@@ -2385,48 +2268,26 @@ test.serial('set operations (intersect) as function', async (t) => {
 	t.assert(result.length === 0);
 
 	t.deepEqual(result, []);
+
+	t.throws(() => {
+		intersect(
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (intersect all) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
@@ -2442,48 +2303,22 @@ test.serial('set operations (intersect all) from query builder', async (t) => {
 		{ id: 1, name: 'New York' },
 		{ id: 2, name: 'London' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ id: citiesTable.id, name: citiesTable.name })
+			.from(citiesTable).limit(2).intersectAll(
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable).limit(2),
+			).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (intersect all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await intersectAll(
 		db
@@ -2502,48 +2337,26 @@ test.serial('set operations (intersect all) as function', async (t) => {
 	t.deepEqual(result, [
 		{ id: 1, name: 'John' },
 	]);
+
+	t.throws(() => {
+		intersectAll(
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (except) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -2563,43 +2376,7 @@ test.serial('set operations (except) from query builder', async (t) => {
 test.serial('set operations (except) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await except(
 		db
@@ -2619,48 +2396,26 @@ test.serial('set operations (except) as function', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		except(
+			db
+				.select({ name: citiesTable.name, id: citiesTable.id })
+				.from(citiesTable),
+			db
+				.select({ id: citiesTable.id, name: citiesTable.name })
+				.from(citiesTable).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (except all) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -2676,48 +2431,22 @@ test.serial('set operations (except all) from query builder', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select()
+			.from(citiesTable).exceptAll(
+				db
+					.select({ name: citiesTable.name, id: citiesTable.id })
+					.from(citiesTable).where(eq(citiesTable.id, 1)),
+			).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (except all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await exceptAll(
 		db
@@ -2741,48 +2470,26 @@ test.serial('set operations (except all) as function', async (t) => {
 		{ id: 6, name: 'Jill' },
 		{ id: 7, name: 'Mary' },
 	]);
+
+	t.throws(() => {
+		exceptAll(
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(gt(users2Table.id, 7)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (mixed) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -2801,48 +2508,26 @@ test.serial('set operations (mixed) from query builder', async (t) => {
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
 	]);
+
+	t.throws(() => {
+		db
+			.select()
+			.from(citiesTable).except(
+				({ unionAll }) =>
+					unionAll(
+						db
+							.select({ name: citiesTable.name, id: citiesTable.id })
+							.from(citiesTable).where(gt(citiesTable.id, 1)),
+						db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
+					),
+			);
+	});
 });
 
 test.serial('set operations (mixed all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-
-	await db.insert(citiesTable).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await union(
 		db
@@ -2870,4 +2555,22 @@ test.serial('set operations (mixed all) as function', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			except(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(gte(users2Table.id, 5)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 7)),
+			),
+			db
+				.select().from(citiesTable).where(gt(citiesTable.id, 1)),
+		);
+	});
 });
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index d69f12555..eaad3c4d6 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -292,6 +292,45 @@ test.beforeEach(async (t) => {
 	);
 });
 
+async function setupSetOperationTest(db: NodePgDatabase) {
+	await db.execute(sql`drop table if exists users2`);
+	await db.execute(sql`drop table if exists cities`);
+	await db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+
+	await db.insert(cities2Table).values([
+		{ id: 1, name: 'New York' },
+		{ id: 2, name: 'London' },
+		{ id: 3, name: 'Tampa' },
+	]);
+
+	await db.insert(users2Table).values([
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 2, name: 'Jane', cityId: 2 },
+		{ id: 3, name: 'Jack', cityId: 3 },
+		{ id: 4, name: 'Peter', cityId: 3 },
+		{ id: 5, name: 'Ben', cityId: 2 },
+		{ id: 6, name: 'Jill', cityId: 1 },
+		{ id: 7, name: 'Mary', cityId: 2 },
+		{ id: 8, name: 'Sally', cityId: 1 },
+	]);
+}
+
 test.serial('table configs: unique third param', async (t) => {
 	const cities1Table = pgTable('cities1', {
 		id: serial('id').primaryKey(),
@@ -2520,42 +2559,7 @@ test.serial('array operators', async (t) => {
 test.serial('set operations (union) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: cities2Table.id, name: citiesTable.name })
@@ -2580,47 +2584,23 @@ test.serial('set operations (union) from query builder', async (t) => {
 		{ id: 8, name: 'Sally' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name, name2: users2Table.name })
+			.from(cities2Table).union(
+				// @ts-expect-error
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table),
+			).orderBy(asc(sql`name`));
+	});
 });
 
 test.serial('set operations (union) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await union(
 		db
@@ -2640,47 +2620,26 @@ test.serial('set operations (union) as function', async (t) => {
 		{ id: 1, name: 'John' },
 		{ id: 1, name: 'New York' },
 	]);
+
+	t.throws(() => {
+		union(
+			db
+				.select({ name: citiesTable.name, id: cities2Table.id })
+				.from(cities2Table).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).orderBy(asc(sql`name`));
+	});
 });
 
 test.serial('set operations (union all) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: cities2Table.id, name: citiesTable.name })
@@ -2698,47 +2657,22 @@ test.serial('set operations (union all) from query builder', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 2, name: 'London' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table).limit(2).unionAll(
+				db
+					.select({ name: citiesTable.name, id: cities2Table.id })
+					.from(cities2Table).limit(2),
+			).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (union all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await unionAll(
 		db
@@ -2759,47 +2693,26 @@ test.serial('set operations (union all) as function', async (t) => {
 		{ id: 1, name: 'John' },
 		{ id: 1, name: 'John' },
 	]);
+
+	t.throws(() => {
+		unionAll(
+			db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table).where(eq(citiesTable.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (intersect) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: cities2Table.id, name: citiesTable.name })
@@ -2815,47 +2728,23 @@ test.serial('set operations (intersect) from query builder', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table).intersect(
+				// @ts-expect-error
+				db
+					.select({ id: cities2Table.id, name: citiesTable.name, id2: cities2Table.id })
+					.from(cities2Table).where(gt(citiesTable.id, 1)),
+			).orderBy(asc(sql`name`));
+	});
 });
 
 test.serial('set operations (intersect) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await intersect(
 		db
@@ -2872,47 +2761,26 @@ test.serial('set operations (intersect) as function', async (t) => {
 	t.assert(result.length === 0);
 
 	t.deepEqual(result, []);
+
+	t.throws(() => {
+		intersect(
+			db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (intersect all) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select({ id: cities2Table.id, name: citiesTable.name })
@@ -2928,47 +2796,22 @@ test.serial('set operations (intersect all) from query builder', async (t) => {
 		{ id: 1, name: 'New York' },
 		{ id: 2, name: 'London' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ id: cities2Table.id, name: citiesTable.name })
+			.from(cities2Table).limit(2).intersectAll(
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(cities2Table).limit(2),
+			).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (intersect all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await intersectAll(
 		db
@@ -2987,47 +2830,26 @@ test.serial('set operations (intersect all) as function', async (t) => {
 	t.deepEqual(result, [
 		{ id: 1, name: 'John' },
 	]);
+
+	t.throws(() => {
+		intersectAll(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		);
+	});
 });
 
 test.serial('set operations (except) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -3042,47 +2864,22 @@ test.serial('set operations (except) from query builder', async (t) => {
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
 	]);
+
+	t.throws(() => {
+		db
+			.select()
+			.from(cities2Table).except(
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(cities2Table).where(gt(citiesTable.id, 1)),
+			);
+	});
 });
 
 test.serial('set operations (except) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await except(
 		db
@@ -3102,47 +2899,26 @@ test.serial('set operations (except) as function', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		except(
+			db
+				.select({ id: cities2Table.id, name: citiesTable.name })
+				.from(cities2Table),
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(cities2Table).where(eq(citiesTable.id, 1)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (except all) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -3158,47 +2934,22 @@ test.serial('set operations (except all) from query builder', async (t) => {
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
+
+	t.throws(() => {
+		db
+			.select({ name: cities2Table.name, id: cities2Table.id })
+			.from(cities2Table).exceptAll(
+				db
+					.select({ id: cities2Table.id, name: citiesTable.name })
+					.from(cities2Table).where(eq(citiesTable.id, 1)),
+			).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (except all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await exceptAll(
 		db
@@ -3222,47 +2973,26 @@ test.serial('set operations (except all) as function', async (t) => {
 		{ id: 6, name: 'Jill' },
 		{ id: 7, name: 'Mary' },
 	]);
+
+	t.throws(() => {
+		exceptAll(
+			db
+				.select({ name: users2Table.name, id: users2Table.id })
+				.from(users2Table),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(gt(users2Table.id, 7)),
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+		).orderBy(asc(sql`id`));
+	});
 });
 
 test.serial('set operations (mixed) from query builder', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await db
 		.select()
@@ -3281,47 +3011,26 @@ test.serial('set operations (mixed) from query builder', async (t) => {
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
 	]);
+
+	t.throws(() => {
+		db
+			.select()
+			.from(cities2Table).except(
+				({ unionAll }) =>
+					unionAll(
+						db
+							.select({ name: cities2Table.name, id: cities2Table.id })
+							.from(cities2Table).where(gt(citiesTable.id, 1)),
+						db.select().from(cities2Table).where(eq(citiesTable.id, 2)),
+					),
+			);
+	});
 });
 
 test.serial('set operations (mixed all) as function', async (t) => {
 	const { db } = t.context;
 
-	await db.execute(sql`drop table if exists users2`);
-	await db.execute(sql`drop table if exists cities`);
-	await db.execute(
-		sql`
-			create table cities (
-				id serial primary key,
-				name text not null
-			)
-		`,
-	);
-	await db.execute(
-		sql`
-			create table users2 (
-				id serial primary key,
-				name text not null,
-				city_id integer references cities(id)
-			)
-		`,
-	);
-
-	await db.insert(cities2Table).values([
-		{ id: 1, name: 'New York' },
-		{ id: 2, name: 'London' },
-		{ id: 3, name: 'Tampa' },
-	]);
-
-	await db.insert(users2Table).values([
-		{ id: 1, name: 'John', cityId: 1 },
-		{ id: 2, name: 'Jane', cityId: 2 },
-		{ id: 3, name: 'Jack', cityId: 3 },
-		{ id: 4, name: 'Peter', cityId: 3 },
-		{ id: 5, name: 'Ben', cityId: 2 },
-		{ id: 6, name: 'Jill', cityId: 1 },
-		{ id: 7, name: 'Mary', cityId: 2 },
-		{ id: 8, name: 'Sally', cityId: 1 },
-	]);
+	await setupSetOperationTest(db);
 
 	const result = await union(
 		db
@@ -3349,4 +3058,22 @@ test.serial('set operations (mixed all) as function', async (t) => {
 		{ id: 6, name: 'Jill' },
 		{ id: 8, name: 'Sally' },
 	]);
+
+	t.throws(() => {
+		union(
+			db
+				.select({ id: users2Table.id, name: users2Table.name })
+				.from(users2Table).where(eq(users2Table.id, 1)),
+			except(
+				db
+					.select({ id: users2Table.id, name: users2Table.name })
+					.from(users2Table).where(gte(users2Table.id, 5)),
+				db
+					.select({ name: users2Table.name, id: users2Table.id })
+					.from(users2Table).where(eq(users2Table.id, 7)),
+			),
+			db
+				.select().from(cities2Table).where(gt(citiesTable.id, 1)),
+		).orderBy(asc(sql`id`));
+	});
 });

From 9281dc292ddff0ee14675f4fda512916a157333d Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sat, 23 Sep 2023 20:16:36 -0400
Subject: [PATCH 26/72] [All] code cleanup and eslint rules fix

---
 .../query-builders/set-operators.ts           | 196 +++-----------
 .../pg-core/query-builders/set-operators.ts   | 195 +++-----------
 .../query-builders/set-operators.ts           | 246 +++---------------
 drizzle-orm/src/utils.ts                      |   4 +-
 4 files changed, 99 insertions(+), 542 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 5c7c3cf0a..a1d7c95dc 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -117,65 +117,32 @@ export abstract class MySqlSetOperatorBuilder<
 			fields: this.config.fields,
 		};
 	}
-	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
 
-		return new MySqlSetOperator('union', false, this, rightSelectOrig);
-	}
-
-	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+	setOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
 		rightSelect:
 			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
 			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
-
-		return new MySqlSetOperator('union', true, this, rightSelectOrig);
-	}
-
-	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
-
-		return new MySqlSetOperator('intersect', false, this, rightSelectOrig);
+	) => MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+		return (rightSelect) => {
+			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+			return new MySqlSetOperator(type, isAll, this, rightSelectOrig);
+		};
 	}
 
-	intersectAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+	union = this.setOperator('union', false);
 
-		return new MySqlSetOperator('intersect', true, this, rightSelectOrig);
-	}
+	unionAll = this.setOperator('union', true);
 
-	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+	intersect = this.setOperator('intersect', false);
 
-		return new MySqlSetOperator('except', false, this, rightSelectOrig);
-	}
+	intersectAll = this.setOperator('intersect', true);
 
-	exceptAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
+	except = this.setOperator('except', false);
 
-		return new MySqlSetOperator('except', true, this, rightSelectOrig);
-	}
+	exceptAll = this.setOperator('except', true);
 
 	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): this;
 	abstract orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): this;
@@ -350,53 +317,7 @@ export class MySqlSetOperator<
 
 applyMixins(MySqlSetOperatorBuilder, [QueryPromise]);
 
-export function union<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new MySqlSetOperator('union', false, leftSelect, rightSelect);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return union(new MySqlSetOperator('union', false, leftSelect, rightSelect), select, ...rest);
-}
-
-export function unionAll<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new MySqlSetOperator('union', true, leftSelect, rightSelect);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return unionAll(new MySqlSetOperator('union', true, leftSelect, rightSelect), select, ...rest);
-}
-
-export function intersect<
+function setOperator(type: SetOperator, isAll: boolean): <
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -408,82 +329,27 @@ export function intersect<
 	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new MySqlSetOperator('intersect', false, leftSelect, rightSelect);
-	}
+) => MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		if (restSelects.length === 0) {
+			return new MySqlSetOperator(type, isAll, leftSelect, rightSelect);
+		}
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+		const [select, ...rest] = restSelects;
+		if (!select) throw new Error('Cannot pass undefined values to any set operator');
 
-	return intersect(new MySqlSetOperator('intersect', false, leftSelect, rightSelect!), select, ...rest);
+		return setOperator(type, isAll)(new MySqlSetOperator(type, isAll, leftSelect, rightSelect), select, ...rest);
+	};
 }
 
-export function intersectAll<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new MySqlSetOperator('intersect', true, leftSelect, rightSelect);
-	}
+export const union = setOperator('union', false);
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+export const unionAll = setOperator('union', true);
 
-	return intersectAll(new MySqlSetOperator('intersect', true, leftSelect, rightSelect!), select, ...rest);
-}
+export const intersect = setOperator('intersect', false);
 
-export function except<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+export const intersectAll = setOperator('intersect', true);
 
-	return except(new MySqlSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
-}
+export const except = setOperator('except', false);
 
-export function exceptAll<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new MySqlSetOperator('except', false, leftSelect, rightSelect);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return exceptAll(new MySqlSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
-}
+export const exceptAll = setOperator('except', true);
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index 03293cbf9..e925ebad1 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -97,65 +97,33 @@ export abstract class PgSetOperatorBuilder<
 			fields: this.config.fields,
 		};
 	}
-	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
 
-		return new PgSetOperator('union', false, this, rightSelectOrig);
-	}
-
-	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+	setOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
 		rightSelect:
 			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
 			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
-
-		return new PgSetOperator('union', true, this, rightSelectOrig);
-	}
+	) => PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+		return (rightSelect) => {
+			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
 
-	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
-
-		return new PgSetOperator('intersect', false, this, rightSelectOrig);
+			return new PgSetOperator(type, isAll, this, rightSelectOrig);
+		};
 	}
 
-	intersectAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+	union = this.setOperator('union', false);
 
-		return new PgSetOperator('intersect', true, this, rightSelectOrig);
-	}
+	unionAll = this.setOperator('union', true);
 
-	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+	intersect = this.setOperator('intersect', false);
 
-		return new PgSetOperator('except', false, this, rightSelectOrig);
-	}
+	intersectAll = this.setOperator('intersect', true);
 
-	exceptAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
+	except = this.setOperator('except', false);
 
-		return new PgSetOperator('except', true, this, rightSelectOrig);
-	}
+	exceptAll = this.setOperator('except', true);
 
 	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
 	abstract orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
@@ -348,7 +316,7 @@ export class PgSetOperator<
 
 applyMixins(PgSetOperator, [QueryPromise]);
 
-export function union<
+function setOperator(type: SetOperator, isAll: boolean): <
 	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
@@ -360,128 +328,27 @@ export function union<
 	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new PgSetOperator('union', false, leftSelect, rightSelect);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return union(new PgSetOperator('union', false, leftSelect, rightSelect), select, ...rest);
-}
-
-export function unionAll<
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new PgSetOperator('union', true, leftSelect, rightSelect);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return unionAll(new PgSetOperator('union', true, leftSelect, rightSelect), select, ...rest);
-}
-
-export function intersect<
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new PgSetOperator('intersect', false, leftSelect, rightSelect);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return intersect(new PgSetOperator('intersect', false, leftSelect, rightSelect!), select, ...rest);
-}
-
-export function intersectAll<
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new PgSetOperator('intersect', true, leftSelect, rightSelect);
-	}
+) => PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		if (restSelects.length === 0) {
+			return new PgSetOperator(type, isAll, leftSelect, rightSelect);
+		}
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+		const [select, ...rest] = restSelects;
+		if (!select) throw new Error('Cannot pass undefined values to any set operator');
 
-	return intersectAll(new PgSetOperator('intersect', true, leftSelect, rightSelect!), select, ...rest);
+		return setOperator(type, isAll)(new PgSetOperator(type, isAll, leftSelect, rightSelect), select, ...rest);
+	};
 }
 
-export function except<
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new PgSetOperator('except', false, leftSelect, rightSelect);
-	}
+export const union = setOperator('union', false);
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+export const unionAll = setOperator('union', true);
 
-	return except(new PgSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
-}
+export const intersect = setOperator('intersect', false);
 
-export function exceptAll<
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new PgSetOperator('except', false, leftSelect, rightSelect);
-	}
+export const intersectAll = setOperator('intersect', true);
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
+export const except = setOperator('except', false);
 
-	return exceptAll(new PgSetOperator('except', false, leftSelect, rightSelect!), select, ...rest);
-}
+export const exceptAll = setOperator('except', true);
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index 635249786..239721209 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -95,65 +95,34 @@ export abstract class SQLiteSetOperatorBuilder<
 			fields: this.config.fields,
 		};
 	}
-	union<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
-
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'union',
-			false,
-			this,
-			rightSelectOrig,
-		);
-	}
 
-	unionAll<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+	setOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
 		rightSelect:
 			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
 			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
-
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'union',
-			true,
-			this,
-			rightSelectOrig,
-		);
+	) => SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+		return (rightSelect) => {
+			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
+
+			return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+				type,
+				isAll,
+				this,
+				rightSelectOrig,
+			);
+		};
 	}
 
-	intersect<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
-
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'intersect',
-			false,
-			this,
-			rightSelectOrig,
-		);
-	}
+	union = this.setOperator('union', false);
 
-	except<TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
-		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-		const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
-
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'except',
-			false,
-			this,
-			rightSelectOrig,
-		);
-	}
+	unionAll = this.setOperator('union', true);
+
+	intersect = this.setOperator('intersect', false);
+
+	except = this.setOperator('except', false);
 
 	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
 	abstract orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): this;
@@ -365,7 +334,7 @@ export class SQLiteSetOperator<
 
 applyMixins(SQLiteSetOperator, [QueryPromise]);
 
-export function union<
+function setOperator(type: SetOperator, isAll: boolean): <
 	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
@@ -387,168 +356,23 @@ export function union<
 	>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'union',
-			false,
-			leftSelect,
-			rightSelect,
-		);
-	}
+) => SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		if (restSelects.length === 0) {
+			return new SQLiteSetOperator(type, isAll, leftSelect, rightSelect);
+		}
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return union(
-		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'union',
-			false,
-			leftSelect,
-			rightSelect,
-		),
-		select,
-		...rest,
-	);
-}
+		const [select, ...rest] = restSelects;
+		if (!select) throw new Error('Cannot pass undefined values to any set operator');
 
-export function unionAll<
-	THKT extends SQLiteSelectHKTBase,
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: SQLiteSetOperatorBuilder<
-		THKT,
-		TTableName,
-		TResultType,
-		TRunResult,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap
-	>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'union',
-			true,
-			leftSelect,
-			rightSelect,
-		);
-	}
-
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return unionAll(
-		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'union',
-			true,
-			leftSelect,
-			rightSelect,
-		),
-		select,
-		...rest,
-	);
+		return setOperator(type, isAll)(new SQLiteSetOperator(type, isAll, leftSelect, rightSelect), select, ...rest);
+	};
 }
 
-export function intersect<
-	THKT extends SQLiteSelectHKTBase,
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: SQLiteSetOperatorBuilder<
-		THKT,
-		TTableName,
-		TResultType,
-		TRunResult,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap
-	>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'intersect',
-			false,
-			leftSelect,
-			rightSelect,
-		);
-	}
+export const union = setOperator('union', false);
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return intersect(
-		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'intersect',
-			false,
-			leftSelect,
-			rightSelect!,
-		),
-		select,
-		...rest,
-	);
-}
+export const unionAll = setOperator('union', true);
 
-export function except<
-	THKT extends SQLiteSelectHKTBase,
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: SQLiteSetOperatorBuilder<
-		THKT,
-		TTableName,
-		TResultType,
-		TRunResult,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap
-	>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-): SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
-	if (restSelects.length === 0) {
-		return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'except',
-			false,
-			leftSelect,
-			rightSelect,
-		);
-	}
+export const intersect = setOperator('intersect', false);
 
-	const [select, ...rest] = restSelects;
-	if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-	return except(
-		new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
-			'except',
-			false,
-			leftSelect,
-			rightSelect!,
-		),
-		select,
-		...rest,
-	);
-}
+export const except = setOperator('except', false);
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index 4a1d40939..02420d261 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -99,8 +99,8 @@ export function haveSameKeys(left: Record<string, unknown>, right: Record<string
 		return false;
 	}
 
-	for (let i = 0; i < leftKeys.length; i++) {
-		if (leftKeys[i] !== rightKeys[i]) {
+	for (const [index, key] of leftKeys.entries()) {
+		if (key !== rightKeys[index]) {
 			return false;
 		}
 	}

From 7618db5d816fb24130c4d63c5c6955caf0b06d54 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sun, 24 Sep 2023 01:26:56 -0400
Subject: [PATCH 27/72] [All] Added offset

---
 .../query-builders/set-operators.ts           | 15 ++++++-
 .../pg-core/query-builders/set-operators.ts   | 15 ++++++-
 .../query-builders/set-operators.ts           | 15 ++++++-
 integration-tests/tests/libsql.test.ts        | 23 +++-------
 integration-tests/tests/mysql.test.ts         | 45 ++++++++-----------
 integration-tests/tests/pg.test.ts            | 24 +++-------
 6 files changed, 71 insertions(+), 66 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index a1d7c95dc..7c42d6db9 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -103,6 +103,7 @@ export abstract class MySqlSetOperatorBuilder<
 		fields: Record<string, unknown>;
 		limit?: number | Placeholder;
 		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+		offset?: number | Placeholder;
 	};
 	/* @internal */
 	abstract readonly session: MySqlSession | undefined;
@@ -118,7 +119,7 @@ export abstract class MySqlSetOperatorBuilder<
 		};
 	}
 
-	setOperator(
+	private setOperator(
 		type: SetOperator,
 		isAll: boolean,
 	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
@@ -148,6 +149,8 @@ export abstract class MySqlSetOperatorBuilder<
 	abstract orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): this;
 
 	abstract limit(limit: number): this;
+
+	abstract offset(offset: number | Placeholder): this;
 }
 
 export class MySqlSetOperator<
@@ -171,6 +174,7 @@ export class MySqlSetOperator<
 		fields: Record<string, unknown>;
 		limit?: number | Placeholder;
 		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+		offset?: number | Placeholder;
 	};
 	/* @internal */
 	readonly session: MySqlSession | undefined;
@@ -237,6 +241,11 @@ export class MySqlSetOperator<
 		return this;
 	}
 
+	offset(offset: number | Placeholder) {
+		this.config.offset = offset;
+		return this;
+	}
+
 	override getSQL(): SQL<unknown> {
 		const leftChunk = sql`(${this.leftSelect.getSQL()}) `;
 		const rightChunk = sql`(${this.rightSelect.getSQL()})`;
@@ -272,7 +281,9 @@ export class MySqlSetOperator<
 
 		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
 
-		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}`;
+		const offsetSql = this.config.offset ? sql` offset ${this.config.offset}` : undefined;
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
 	toSQL(): Query {
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index e925ebad1..0157e4982 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -83,6 +83,7 @@ export abstract class PgSetOperatorBuilder<
 		fields: Record<string, unknown>;
 		limit?: number | Placeholder;
 		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+		offset?: number | Placeholder;
 	};
 	/* @internal */
 	protected abstract readonly session: PgSession | undefined;
@@ -98,7 +99,7 @@ export abstract class PgSetOperatorBuilder<
 		};
 	}
 
-	setOperator(
+	private setOperator(
 		type: SetOperator,
 		isAll: boolean,
 	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
@@ -129,6 +130,8 @@ export abstract class PgSetOperatorBuilder<
 	abstract orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
 
 	abstract limit(limit: number): this;
+
+	abstract offset(offset: number | Placeholder): this;
 }
 
 export interface PgSetOperator<
@@ -168,6 +171,7 @@ export class PgSetOperator<
 		fields: Record<string, unknown>;
 		limit?: number | Placeholder;
 		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+		offset?: number | Placeholder;
 	};
 	/* @internal */
 	readonly session: PgSession | undefined;
@@ -230,6 +234,11 @@ export class PgSetOperator<
 		return this;
 	}
 
+	offset(offset: number | Placeholder) {
+		this.config.offset = offset;
+		return this;
+	}
+
 	toSQL(): Query {
 		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
 		return rest;
@@ -270,7 +279,9 @@ export class PgSetOperator<
 
 		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
 
-		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}`;
+		const offsetSql = this.config.offset ? sql` offset ${this.config.offset}` : undefined;
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
 	private _prepare(name?: string): PreparedQuery<
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index 239721209..ce56ae5d6 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -81,6 +81,7 @@ export abstract class SQLiteSetOperatorBuilder<
 		fields: Record<string, unknown>;
 		limit?: number | Placeholder;
 		orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+		offset?: number | Placeholder;
 	};
 	/* @internal */
 	protected abstract readonly session: SQLiteSession<any, any, any, any> | undefined;
@@ -96,7 +97,7 @@ export abstract class SQLiteSetOperatorBuilder<
 		};
 	}
 
-	setOperator(
+	private setOperator(
 		type: SetOperator,
 		isAll: boolean,
 	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
@@ -128,6 +129,8 @@ export abstract class SQLiteSetOperatorBuilder<
 	abstract orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): this;
 
 	abstract limit(limit: number): this;
+
+	abstract offset(offset: number | Placeholder): this;
 }
 
 export interface SQLiteSetOperator<
@@ -175,6 +178,7 @@ export class SQLiteSetOperator<
 		fields: Record<string, unknown>;
 		limit?: number | Placeholder;
 		orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+		offset?: number | Placeholder;
 	};
 	/* @internal */
 	readonly session: SQLiteSession<any, any, any, any> | undefined;
@@ -245,6 +249,11 @@ export class SQLiteSetOperator<
 		return this;
 	}
 
+	offset(offset: number | Placeholder) {
+		this.config.offset = offset;
+		return this;
+	}
+
 	toSQL(): Query {
 		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
 		return rest;
@@ -285,7 +294,9 @@ export class SQLiteSetOperator<
 
 		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
 
-		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}`;
+		const offsetSql = this.config.offset ? sql` offset ${this.config.offset}` : undefined;
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
 	prepare(isOneTimeQuery?: boolean): PreparedQuery<
diff --git a/integration-tests/tests/libsql.test.ts b/integration-tests/tests/libsql.test.ts
index 1414a96ce..9c4748b80 100644
--- a/integration-tests/tests/libsql.test.ts
+++ b/integration-tests/tests/libsql.test.ts
@@ -2023,22 +2023,16 @@ test.serial('set operations (union) from query builder', async (t) => {
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table),
-		).orderBy(asc(sql`name`));
+		).orderBy(asc(sql`name`)).limit(5).offset(5);
 
-	t.assert(result.length === 11);
+	t.assert(result.length === 5);
 
 	t.deepEqual(result, [
-		{ id: 5, name: 'Ben' },
-		{ id: 3, name: 'Jack' },
-		{ id: 2, name: 'Jane' },
-		{ id: 6, name: 'Jill' },
-		{ id: 1, name: 'John' },
 		{ id: 2, name: 'London' },
 		{ id: 7, name: 'Mary' },
 		{ id: 1, name: 'New York' },
 		{ id: 4, name: 'Peter' },
 		{ id: 8, name: 'Sally' },
-		{ id: 3, name: 'Tampa' },
 	]);
 
 	t.throws(() => {
@@ -2102,12 +2096,11 @@ test.serial('set operations (union all) from query builder', async (t) => {
 			db
 				.select({ id: citiesTable.id, name: citiesTable.name })
 				.from(citiesTable),
-		).orderBy(asc(citiesTable.id));
+		).orderBy(asc(citiesTable.id)).limit(5).offset(1);
 
-	t.assert(result.length === 6);
+	t.assert(result.length === 5);
 
 	t.deepEqual(result, [
-		{ id: 1, name: 'New York' },
 		{ id: 1, name: 'New York' },
 		{ id: 2, name: 'London' },
 		{ id: 2, name: 'London' },
@@ -2122,7 +2115,7 @@ test.serial('set operations (union all) from query builder', async (t) => {
 				db
 					.select({ name: citiesTable.name, id: citiesTable.id })
 					.from(citiesTable),
-			).orderBy(asc(citiesTable.id));
+			).orderBy(asc(citiesTable.id)).limit(5).offset(1);
 	});
 });
 
@@ -2361,17 +2354,15 @@ test.serial('set operations (mixed all) as function', async (t) => {
 		),
 		db
 			.select().from(citiesTable).where(gt(citiesTable.id, 1)),
-	).orderBy(asc(sql`id`));
+	).orderBy(asc(sql`id`)).limit(4).offset(1);
 
-	t.assert(result.length === 6);
+	t.assert(result.length === 4);
 
 	t.deepEqual(result, [
-		{ id: 1, name: 'John' },
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 		{ id: 5, name: 'Ben' },
 		{ id: 6, name: 'Jill' },
-		{ id: 8, name: 'Sally' },
 	]);
 
 	t.throws(() => {
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index f25a55328..d7eab61b1 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -2075,9 +2075,9 @@ test.serial('set operations (union) from query builder', async (t) => {
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table),
-		);
+		).limit(8);
 
-	t.assert(result.length === 11);
+	t.assert(result.length === 8);
 
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
@@ -2088,9 +2088,6 @@ test.serial('set operations (union) from query builder', async (t) => {
 		{ id: 3, name: 'Jack' },
 		{ id: 4, name: 'Peter' },
 		{ id: 5, name: 'Ben' },
-		{ id: 6, name: 'Jill' },
-		{ id: 7, name: 'Mary' },
-		{ id: 8, name: 'Sally' },
 	]);
 
 	// union should throw if selected fields are not in the same order
@@ -2155,15 +2152,14 @@ test.serial('set operations (union all) from query builder', async (t) => {
 			db
 				.select({ id: citiesTable.id, name: citiesTable.name })
 				.from(citiesTable).limit(2),
-		).orderBy(asc(sql`id`));
+		).orderBy(asc(sql`id`)).limit(3);
 
-	t.assert(result.length === 4);
+	t.assert(result.length === 3);
 
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
 		{ id: 1, name: 'New York' },
 		{ id: 2, name: 'London' },
-		{ id: 2, name: 'London' },
 	]);
 
 	t.throws(() => {
@@ -2192,14 +2188,12 @@ test.serial('set operations (union all) as function', async (t) => {
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-	);
+	).limit(1);
 
-	t.assert(result.length === 3);
+	t.assert(result.length === 1);
 
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
-		{ id: 1, name: 'John' },
-		{ id: 1, name: 'John' },
 	]);
 
 	t.throws(() => {
@@ -2213,7 +2207,7 @@ test.serial('set operations (union all) as function', async (t) => {
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table).where(eq(users2Table.id, 1)),
-		);
+		).limit(1);
 	});
 });
 
@@ -2263,7 +2257,7 @@ test.serial('set operations (intersect) as function', async (t) => {
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-	);
+	).limit(1);
 
 	t.assert(result.length === 0);
 
@@ -2280,7 +2274,7 @@ test.serial('set operations (intersect) as function', async (t) => {
 			db
 				.select({ name: users2Table.name, id: users2Table.id })
 				.from(users2Table).where(eq(users2Table.id, 1)),
-		);
+		).limit(1);
 	});
 });
 
@@ -2388,7 +2382,7 @@ test.serial('set operations (except) as function', async (t) => {
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-	);
+	).limit(3);
 
 	t.assert(result.length === 2);
 
@@ -2408,7 +2402,7 @@ test.serial('set operations (except) as function', async (t) => {
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table).where(eq(users2Table.id, 1)),
-		);
+		).limit(3);
 	});
 });
 
@@ -2458,7 +2452,7 @@ test.serial('set operations (except all) as function', async (t) => {
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-	);
+	).limit(6);
 
 	t.assert(result.length === 6);
 
@@ -2482,7 +2476,7 @@ test.serial('set operations (except all) as function', async (t) => {
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table).where(eq(users2Table.id, 1)),
-		);
+		).limit(6);
 	});
 });
 
@@ -2500,13 +2494,14 @@ test.serial('set operations (mixed) from query builder', async (t) => {
 						.select()
 						.from(citiesTable).where(gt(citiesTable.id, 1)),
 					db.select().from(citiesTable).where(eq(citiesTable.id, 2)),
-				),
+				).orderBy(asc(citiesTable.id)).limit(1).offset(1),
 		);
 
-	t.assert(result.length === 1);
+	t.assert(result.length === 2);
 
 	t.deepEqual(result, [
 		{ id: 1, name: 'New York' },
+		{ id: 3, name: 'Tampa' },
 	]);
 
 	t.throws(() => {
@@ -2540,18 +2535,16 @@ test.serial('set operations (mixed all) as function', async (t) => {
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table).where(eq(users2Table.id, 7)),
-		),
+		).limit(1),
 		db
 			.select().from(citiesTable).where(gt(citiesTable.id, 1)),
 	);
 
-	t.assert(result.length === 6);
+	t.assert(result.length === 4);
 
 	t.deepEqual(result, [
 		{ id: 1, name: 'John' },
 		{ id: 5, name: 'Ben' },
-		{ id: 6, name: 'Jill' },
-		{ id: 8, name: 'Sally' },
 		{ id: 2, name: 'London' },
 		{ id: 3, name: 'Tampa' },
 	]);
@@ -2568,7 +2561,7 @@ test.serial('set operations (mixed all) as function', async (t) => {
 				db
 					.select({ name: users2Table.name, id: users2Table.id })
 					.from(users2Table).where(eq(users2Table.id, 7)),
-			),
+			).limit(1),
 			db
 				.select().from(citiesTable).where(gt(citiesTable.id, 1)),
 		);
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index eaad3c4d6..d27b42ee9 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -2567,22 +2567,13 @@ test.serial('set operations (union) from query builder', async (t) => {
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table),
-		).orderBy(asc(sql`name`));
+		).orderBy(asc(sql`name`)).limit(2).offset(1);
 
-	t.assert(result.length === 11);
+	t.assert(result.length === 2);
 
 	t.deepEqual(result, [
-		{ id: 5, name: 'Ben' },
 		{ id: 3, name: 'Jack' },
 		{ id: 2, name: 'Jane' },
-		{ id: 6, name: 'Jill' },
-		{ id: 1, name: 'John' },
-		{ id: 2, name: 'London' },
-		{ id: 7, name: 'Mary' },
-		{ id: 1, name: 'New York' },
-		{ id: 4, name: 'Peter' },
-		{ id: 8, name: 'Sally' },
-		{ id: 3, name: 'Tampa' },
 	]);
 
 	t.throws(() => {
@@ -2612,12 +2603,11 @@ test.serial('set operations (union) as function', async (t) => {
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-	).orderBy(asc(sql`name`));
+	).orderBy(asc(sql`name`)).limit(1).offset(1);
 
-	t.assert(result.length === 2);
+	t.assert(result.length === 1);
 
 	t.deepEqual(result, [
-		{ id: 1, name: 'John' },
 		{ id: 1, name: 'New York' },
 	]);
 
@@ -2961,13 +2951,11 @@ test.serial('set operations (except all) as function', async (t) => {
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-	).orderBy(asc(sql`id`));
+	).orderBy(asc(sql`id`)).limit(5).offset(2);
 
-	t.assert(result.length === 6);
+	t.assert(result.length === 4);
 
 	t.deepEqual(result, [
-		{ id: 2, name: 'Jane' },
-		{ id: 3, name: 'Jack' },
 		{ id: 4, name: 'Peter' },
 		{ id: 5, name: 'Ben' },
 		{ id: 6, name: 'Jill' },

From 85be035c8589a44bf9982e1526d9b1a3e1db5eaf Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sun, 24 Sep 2023 01:54:46 -0400
Subject: [PATCH 28/72] [All] added `.as()` method to create subqueries from
 set operations. Added tests

---
 .../query-builders/set-operators.ts           | 11 +++++++
 .../pg-core/query-builders/set-operators.ts   | 11 +++++++
 .../query-builders/set-operators.ts           | 11 +++++++
 drizzle-orm/type-tests/mysql/subquery.ts      | 12 ++++++++
 drizzle-orm/type-tests/pg/subquery.ts         | 12 ++++++++
 drizzle-orm/type-tests/sqlite/subquery.ts     | 12 ++++++++
 integration-tests/tests/libsql.test.ts        | 16 ++++++----
 integration-tests/tests/mysql.test.ts         | 29 ++++++++++---------
 integration-tests/tests/pg.test.ts            | 19 +++++++-----
 9 files changed, 106 insertions(+), 27 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 7c42d6db9..aa50ed0f9 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -9,6 +9,7 @@ import {
 	SelectionProxyHandler,
 	SQL,
 	sql,
+	Subquery,
 	type ValidateShape,
 	type ValueOrArray,
 } from '~/index.ts';
@@ -28,6 +29,7 @@ import type {
 import { type ColumnsSelection } from '~/view.ts';
 import { MySqlColumn } from '../columns/common.ts';
 import type { MySqlDialect } from '../dialect.ts';
+import type { SubqueryWithSelection } from '../subquery.ts';
 
 type SetOperator = 'union' | 'intersect' | 'except';
 
@@ -324,6 +326,15 @@ export class MySqlSetOperator<
 	};
 
 	iterator = this.createIterator();
+
+	as<TAlias extends string>(
+		alias: TAlias,
+	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias, 'mysql'> {
+		return new Proxy(
+			new Subquery(this.getSQL(), this.config.fields, alias),
+			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias, 'mysql'>;
+	}
 }
 
 applyMixins(MySqlSetOperatorBuilder, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index 0157e4982..e56b782f4 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -6,6 +6,7 @@ import {
 	SelectionProxyHandler,
 	SQL,
 	sql,
+	Subquery,
 	type ValueOrArray,
 } from '~/index.ts';
 import type { PgSession, PreparedQuery, PreparedQueryConfig } from '~/pg-core/session.ts';
@@ -22,6 +23,7 @@ import { applyMixins, haveSameKeys, type ValidateShape } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { PgColumn } from '../columns/common.ts';
 import type { PgDialect } from '../dialect.ts';
+import type { SubqueryWithSelection } from '../subquery.ts';
 import type { PgSelectHKTBase } from './select.types.ts';
 
 type SetOperator = 'union' | 'intersect' | 'except';
@@ -323,6 +325,15 @@ export class PgSetOperator<
 			return this._prepare().execute(placeholderValues);
 		});
 	};
+
+	as<TAlias extends string>(
+		alias: TAlias,
+	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias> {
+		return new Proxy(
+			new Subquery(this.getSQL(), this.config.fields, alias),
+			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+	}
 }
 
 applyMixins(PgSetOperator, [QueryPromise]);
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index ce56ae5d6..85d6e1589 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -6,6 +6,7 @@ import {
 	SelectionProxyHandler,
 	SQL,
 	sql,
+	Subquery,
 	type ValueOrArray,
 } from '~/index.ts';
 import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
@@ -21,6 +22,7 @@ import { applyMixins, haveSameKeys, type PromiseOf, type ValidateShape } from '~
 import { type ColumnsSelection } from '~/view.ts';
 import { SQLiteColumn } from '../columns/common.ts';
 import type { SQLiteDialect } from '../dialect.ts';
+import type { SubqueryWithSelection } from '../subquery.ts';
 import type { SQLiteSelectHKTBase } from './select.types.ts';
 
 type SetOperator = 'union' | 'intersect' | 'except';
@@ -341,6 +343,15 @@ export class SQLiteSetOperator<
 	async execute(): Promise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
 		return this.all() as PromiseOf<ReturnType<this['execute']>>;
 	}
+
+	as<TAlias extends string>(
+		alias: TAlias,
+	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias> {
+		return new Proxy(
+			new Subquery(this.getSQL(), this.config.fields, alias),
+			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+	}
 }
 
 applyMixins(SQLiteSetOperator, [QueryPromise]);
diff --git a/drizzle-orm/type-tests/mysql/subquery.ts b/drizzle-orm/type-tests/mysql/subquery.ts
index 920520e45..3408fbc73 100644
--- a/drizzle-orm/type-tests/mysql/subquery.ts
+++ b/drizzle-orm/type-tests/mysql/subquery.ts
@@ -83,3 +83,15 @@ Expect<
 	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
 	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
 }
+
+const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+
+const resUnion = await db.select().from(sqUnion);
+
+Expect<
+	Equal<{
+		id: number;
+		name: string | null;
+		authorId: number | null;
+	}[], typeof resUnion>
+>;
diff --git a/drizzle-orm/type-tests/pg/subquery.ts b/drizzle-orm/type-tests/pg/subquery.ts
index 0af17ccf8..47193c5a4 100644
--- a/drizzle-orm/type-tests/pg/subquery.ts
+++ b/drizzle-orm/type-tests/pg/subquery.ts
@@ -83,3 +83,15 @@ Expect<
 	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
 	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
 }
+
+const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+
+const resUnion = await db.select().from(sqUnion);
+
+Expect<
+	Equal<{
+		id: number;
+		name: string | null;
+		authorId: number | null;
+	}[], typeof resUnion>
+>;
diff --git a/drizzle-orm/type-tests/sqlite/subquery.ts b/drizzle-orm/type-tests/sqlite/subquery.ts
index 87926864e..f67a948cb 100644
--- a/drizzle-orm/type-tests/sqlite/subquery.ts
+++ b/drizzle-orm/type-tests/sqlite/subquery.ts
@@ -84,3 +84,15 @@ Expect<
 	const sq = db.select({ count: sql<number>`count(1)::int` }).from(names).as('sq');
 	Expect<typeof sq.count extends DrizzleTypeError<any> ? true : false>;
 }
+
+const sqUnion = db.select().from(names).union(db.select().from(names2)).as('sqUnion');
+
+const resUnion = await db.select().from(sqUnion);
+
+Expect<
+	Equal<{
+		id: number;
+		name: string | null;
+		authorId: number | null;
+	}[], typeof resUnion>
+>;
diff --git a/integration-tests/tests/libsql.test.ts b/integration-tests/tests/libsql.test.ts
index 9c4748b80..8d87193a6 100644
--- a/integration-tests/tests/libsql.test.ts
+++ b/integration-tests/tests/libsql.test.ts
@@ -2012,18 +2012,20 @@ test.serial('select + .get() for empty result', async (t) => {
 	await db.run(sql`drop table ${users}`);
 });
 
-test.serial('set operations (union) from query builder', async (t) => {
+test.serial('set operations (union) from query builder with subquery', async (t) => {
 	const { db } = t.context;
 
 	await setupSetOperationTest(db);
 
-	const result = await db
+	const sq = db
 		.select({ id: citiesTable.id, name: citiesTable.name })
 		.from(citiesTable).union(
 			db
 				.select({ id: users2Table.id, name: users2Table.name })
 				.from(users2Table),
-		).orderBy(asc(sql`name`)).limit(5).offset(5);
+		).orderBy(asc(sql`name`)).as('sq');
+
+	const result = await db.select().from(sq).limit(5).offset(5);
 
 	t.assert(result.length === 5);
 
@@ -2335,12 +2337,12 @@ test.serial('set operations (mixed) from query builder', async (t) => {
 	});
 });
 
-test.serial('set operations (mixed all) as function', async (t) => {
+test.serial('set operations (mixed all) as function with subquery', async (t) => {
 	const { db } = t.context;
 
 	await setupSetOperationTest(db);
 
-	const result = await union(
+	const sq = union(
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
@@ -2354,7 +2356,9 @@ test.serial('set operations (mixed all) as function', async (t) => {
 		),
 		db
 			.select().from(citiesTable).where(gt(citiesTable.id, 1)),
-	).orderBy(asc(sql`id`)).limit(4).offset(1);
+	).orderBy(asc(sql`id`)).as('sq');
+
+	const result = await db.select().from(sq).limit(4).offset(1);
 
 	t.assert(result.length === 4);
 
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index d7eab61b1..62f41d92a 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -2064,17 +2064,18 @@ test.serial('utc config for datetime', async (t) => {
 	await db.execute(sql`drop table if exists \`datestable\``);
 });
 
-test.serial('set operations (union) from query builder', async (t) => {
+test.serial('set operations (union) from query builder with subquery', async (t) => {
 	const { db } = t.context;
 
 	await setupSetOperationTest(db);
+	const sq = db
+		.select({ id: users2Table.id, name: users2Table.name })
+		.from(users2Table).as('sq');
 
 	const result = await db
 		.select({ id: citiesTable.id, name: citiesTable.name })
 		.from(citiesTable).union(
-			db
-				.select({ id: users2Table.id, name: users2Table.name })
-				.from(users2Table),
+			db.select().from(sq),
 		).limit(8);
 
 	t.assert(result.length === 8);
@@ -2519,23 +2520,25 @@ test.serial('set operations (mixed) from query builder', async (t) => {
 	});
 });
 
-test.serial('set operations (mixed all) as function', async (t) => {
+test.serial('set operations (mixed all) as function with subquery', async (t) => {
 	const { db } = t.context;
 
 	await setupSetOperationTest(db);
 
+	const sq = except(
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(gte(users2Table.id, 5)),
+		db
+			.select({ id: users2Table.id, name: users2Table.name })
+			.from(users2Table).where(eq(users2Table.id, 7)),
+	).as('sq');
+
 	const result = await union(
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-		except(
-			db
-				.select({ id: users2Table.id, name: users2Table.name })
-				.from(users2Table).where(gte(users2Table.id, 5)),
-			db
-				.select({ id: users2Table.id, name: users2Table.name })
-				.from(users2Table).where(eq(users2Table.id, 7)),
-		).limit(1),
+		db.select().from(sq).limit(1),
 		db
 			.select().from(citiesTable).where(gt(citiesTable.id, 1)),
 	);
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index d27b42ee9..a545d4c99 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -2556,17 +2556,19 @@ test.serial('array operators', async (t) => {
 	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });
 
-test.serial('set operations (union) from query builder', async (t) => {
+test.serial('set operations (union) from query builder with subquery', async (t) => {
 	const { db } = t.context;
 
 	await setupSetOperationTest(db);
 
+	const sq = db
+		.select({ id: users2Table.id, name: users2Table.name })
+		.from(users2Table).as('sq');
+
 	const result = await db
 		.select({ id: cities2Table.id, name: citiesTable.name })
 		.from(cities2Table).union(
-			db
-				.select({ id: users2Table.id, name: users2Table.name })
-				.from(users2Table),
+			db.select().from(sq),
 		).orderBy(asc(sql`name`)).limit(2).offset(1);
 
 	t.assert(result.length === 2);
@@ -2977,19 +2979,20 @@ test.serial('set operations (except all) as function', async (t) => {
 	});
 });
 
-test.serial('set operations (mixed) from query builder', async (t) => {
+test.serial('set operations (mixed) from query builder with subquery', async (t) => {
 	const { db } = t.context;
 
 	await setupSetOperationTest(db);
+	const sq = db
+		.select()
+		.from(cities2Table).where(gt(citiesTable.id, 1)).as('sq');
 
 	const result = await db
 		.select()
 		.from(cities2Table).except(
 			({ unionAll }) =>
 				unionAll(
-					db
-						.select()
-						.from(cities2Table).where(gt(citiesTable.id, 1)),
+					db.select().from(sq),
 					db.select().from(cities2Table).where(eq(citiesTable.id, 2)),
 				),
 		);

From 256a292167236f4d1bec73e98337866f0b1cef19 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sun, 24 Sep 2023 12:43:14 -0400
Subject: [PATCH 29/72] [All] Moved the query construction logic to the each
 dialect

---
 drizzle-orm/src/mysql-core/dialect.ts         | 49 ++++++++++++
 .../query-builders/set-operators.ts           | 76 ++++++------------
 drizzle-orm/src/pg-core/dialect.ts            | 55 ++++++++++++-
 .../pg-core/query-builders/set-operators.ts   | 75 ++++++------------
 drizzle-orm/src/sqlite-core/dialect.ts        | 55 ++++++++++++-
 .../query-builders/set-operators.ts           | 77 ++++++-------------
 6 files changed, 231 insertions(+), 156 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index ea6f4ceb9..640d30ddf 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -24,6 +24,7 @@ import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
 import type { Join, MySqlSelectConfig, SelectedFieldsOrdered } from './query-builders/select.types.ts';
+import type { MySqlSetOperatorConfig } from './query-builders/set-operators.ts';
 import type { MySqlUpdateConfig } from './query-builders/update.ts';
 import type { MySqlSession } from './session.ts';
 import { MySqlTable } from './table.ts';
@@ -334,6 +335,54 @@ export class MySqlDialect {
 		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
 	}
 
+	buildSetOperationQuery({
+		operator,
+		isAll,
+		leftSelect,
+		rightSelect,
+		limit,
+		orderBy,
+		offset,
+	}: MySqlSetOperatorConfig): SQL {
+		const leftChunk = sql`(${leftSelect.getSQL()}) `;
+		const rightChunk = sql`(${rightSelect.getSQL()})`;
+
+		let orderBySql;
+		if (orderBy && orderBy.length > 0) {
+			const orderByValues: SQL<unknown>[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const orderByUnit of orderBy) {
+				if (is(orderByUnit, MySqlColumn)) {
+					orderByValues.push(sql.raw(orderByUnit.name));
+				} else if (is(orderByUnit, SQL)) {
+					for (let i = 0; i < orderByUnit.queryChunks.length; i++) {
+						const chunk = orderByUnit.queryChunks[i];
+
+						if (is(chunk, MySqlColumn)) {
+							orderByUnit.queryChunks[i] = sql.raw(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${orderByUnit}`);
+				} else {
+					orderByValues.push(sql`${orderByUnit}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
+		}
+
+		const limitSql = limit ? sql` limit ${limit}` : undefined;
+
+		const operatorChunk = sql.raw(`${operator} ${isAll ? 'all ' : ''}`);
+
+		const offsetSql = offset ? sql` offset ${offset}` : undefined;
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+	}
+
 	buildInsertQuery({ table, values, ignore, onConflict }: MySqlInsertConfig): SQL {
 		// const isSingleValue = values.length === 1;
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index aa50ed0f9..ce76a3963 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -1,4 +1,4 @@
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import {
 	applyMixins,
 	haveSameKeys,
@@ -7,8 +7,7 @@ import {
 	type Query,
 	QueryPromise,
 	SelectionProxyHandler,
-	SQL,
-	sql,
+	type SQL,
 	Subquery,
 	type ValidateShape,
 	type ValueOrArray,
@@ -27,7 +26,7 @@ import type {
 	SelectResult,
 } from '~/query-builders/select.types.ts';
 import { type ColumnsSelection } from '~/view.ts';
-import { MySqlColumn } from '../columns/common.ts';
+import type { MySqlColumn } from '../columns/common.ts';
 import type { MySqlDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
 
@@ -71,6 +70,17 @@ type SetOperatorRestSelect<
 	: never[]
 	: TValue;
 
+export interface MySqlSetOperatorConfig {
+	fields: Record<string, unknown>;
+	operator: SetOperator;
+	isAll: boolean;
+	leftSelect: MySqlSetOperatorBuilder<any, any, any, any, any>;
+	rightSelect: TypedQueryBuilder<any, any[]>;
+	limit?: number | Placeholder;
+	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+	offset?: number | Placeholder;
+}
+
 export interface MySqlSetOperatorBuilder<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
@@ -172,27 +182,22 @@ export class MySqlSetOperator<
 	static readonly [entityKind]: string = 'MySqlSetOperator';
 
 	protected joinsNotNullableMap: Record<string, boolean>;
-	protected config: {
-		fields: Record<string, unknown>;
-		limit?: number | Placeholder;
-		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
-		offset?: number | Placeholder;
-	};
+	protected config: MySqlSetOperatorConfig;
 	/* @internal */
 	readonly session: MySqlSession | undefined;
 	protected dialect: MySqlDialect;
 
 	constructor(
-		private operator: SetOperator,
-		private isAll: boolean,
-		private leftSelect: MySqlSetOperatorBuilder<
+		operator: SetOperator,
+		isAll: boolean,
+		leftSelect: MySqlSetOperatorBuilder<
 			TTableName,
 			TSelection,
 			TSelectMode,
 			TPreparedQueryHKT,
 			TNullabilityMap
 		>,
-		private rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
 		super();
 
@@ -216,6 +221,10 @@ export class MySqlSetOperator<
 		this.joinsNotNullableMap = joinsNotNullableMap;
 		this.config = {
 			fields,
+			operator,
+			isAll,
+			leftSelect,
+			rightSelect,
 		};
 	}
 
@@ -248,44 +257,9 @@ export class MySqlSetOperator<
 		return this;
 	}
 
+	/** @internal */
 	override getSQL(): SQL<unknown> {
-		const leftChunk = sql`(${this.leftSelect.getSQL()}) `;
-		const rightChunk = sql`(${this.rightSelect.getSQL()})`;
-
-		let orderBySql;
-		if (this.config.orderBy && this.config.orderBy.length > 0) {
-			const orderByValues: SQL<unknown>[] = [];
-
-			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
-			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
-			for (const orderBy of this.config.orderBy) {
-				if (is(orderBy, MySqlColumn)) {
-					orderByValues.push(sql.raw(orderBy.name));
-				} else if (is(orderBy, SQL)) {
-					for (let i = 0; i < orderBy.queryChunks.length; i++) {
-						const chunk = orderBy.queryChunks[i];
-
-						if (is(chunk, MySqlColumn)) {
-							orderBy.queryChunks[i] = sql.raw(chunk.name);
-						}
-					}
-
-					orderByValues.push(sql`${orderBy}`);
-				} else {
-					orderByValues.push(sql`${orderBy}`);
-				}
-			}
-
-			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
-		}
-
-		const limitSql = this.config.limit ? sql` limit ${this.config.limit}` : undefined;
-
-		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
-
-		const offsetSql = this.config.offset ? sql` offset ${this.config.offset}` : undefined;
-
-		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+		return this.dialect.buildSetOperationQuery(this.config);
 	}
 
 	toSQL(): Query {
diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 5b255b2bd..0a3bf35e9 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -4,7 +4,12 @@ import { entityKind, is } from '~/entity.ts';
 import { DrizzleError } from '~/errors.ts';
 import type { MigrationMeta } from '~/migrator.ts';
 import { PgColumn, PgDate, PgJson, PgJsonb, PgNumeric, PgTime, PgTimestamp, PgUUID } from '~/pg-core/columns/index.ts';
-import type { PgDeleteConfig, PgInsertConfig, PgUpdateConfig } from '~/pg-core/query-builders/index.ts';
+import type {
+	PgDeleteConfig,
+	PgInsertConfig,
+	PgSetOperationConfig,
+	PgUpdateConfig,
+} from '~/pg-core/query-builders/index.ts';
 import type { Join, PgSelectConfig, SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import { PgTable } from '~/pg-core/table.ts';
 import {
@@ -343,6 +348,54 @@ export class PgDialect {
 		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
 	}
 
+	buildSetOperationQuery({
+		operator,
+		isAll,
+		leftSelect,
+		rightSelect,
+		limit,
+		orderBy,
+		offset,
+	}: PgSetOperationConfig): SQL {
+		const leftChunk = sql`(${leftSelect.getSQL()}) `;
+		const rightChunk = sql`(${rightSelect.getSQL()})`;
+
+		let orderBySql;
+		if (orderBy && orderBy.length > 0) {
+			const orderByValues: SQL<unknown>[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const singleOrderBy of orderBy) {
+				if (is(singleOrderBy, PgColumn)) {
+					orderByValues.push(sql.raw(singleOrderBy.name));
+				} else if (is(singleOrderBy, SQL)) {
+					for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {
+						const chunk = singleOrderBy.queryChunks[i];
+
+						if (is(chunk, PgColumn)) {
+							singleOrderBy.queryChunks[i] = sql.raw(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${singleOrderBy}`);
+				} else {
+					orderByValues.push(sql`${singleOrderBy}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
+		}
+
+		const limitSql = limit ? sql` limit ${limit}` : undefined;
+
+		const operatorChunk = sql.raw(`${operator} ${isAll ? 'all ' : ''}`);
+
+		const offsetSql = offset ? sql` offset ${offset}` : undefined;
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+	}
+
 	buildInsertQuery({ table, values, onConflict, returning }: PgInsertConfig): SQL {
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
 		const columns: Record<string, PgColumn> = table[Table.Symbol.Columns];
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index e56b782f4..c4ddccfa1 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -1,11 +1,10 @@
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import {
 	orderSelectedFields,
 	type Placeholder,
 	type Query,
 	SelectionProxyHandler,
-	SQL,
-	sql,
+	type SQL,
 	Subquery,
 	type ValueOrArray,
 } from '~/index.ts';
@@ -21,7 +20,7 @@ import { QueryPromise } from '~/query-promise.ts';
 import { tracer } from '~/tracing.ts';
 import { applyMixins, haveSameKeys, type ValidateShape } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
-import { PgColumn } from '../columns/common.ts';
+import { type PgColumn } from '../columns/common.ts';
 import type { PgDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
 import type { PgSelectHKTBase } from './select.types.ts';
@@ -66,6 +65,17 @@ type SetOperatorRestSelect<
 	: never[]
 	: TValue;
 
+export interface PgSetOperationConfig {
+	fields: Record<string, unknown>;
+	operator: SetOperator;
+	isAll: boolean;
+	leftSelect: PgSetOperatorBuilder<any, any, any, any, any>;
+	rightSelect: TypedQueryBuilder<any, any[]>;
+	limit?: number | Placeholder;
+	orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+	offset?: number | Placeholder;
+}
+
 export abstract class PgSetOperatorBuilder<
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	THKT extends PgSelectHKTBase,
@@ -169,21 +179,16 @@ export class PgSetOperator<
 	static readonly [entityKind]: string = 'PgSetOperator';
 
 	protected joinsNotNullableMap: Record<string, boolean>;
-	protected config: {
-		fields: Record<string, unknown>;
-		limit?: number | Placeholder;
-		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
-		offset?: number | Placeholder;
-	};
+	protected config: PgSetOperationConfig;
 	/* @internal */
 	readonly session: PgSession | undefined;
 	protected dialect: PgDialect;
 
 	constructor(
-		private operator: SetOperator,
-		private isAll: boolean,
-		private leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-		private rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+		operator: SetOperator,
+		isAll: boolean,
+		leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
 		super();
 
@@ -207,6 +212,10 @@ export class PgSetOperator<
 		this.joinsNotNullableMap = joinsNotNullableMap;
 		this.config = {
 			fields,
+			operator,
+			isAll,
+			leftSelect,
+			rightSelect,
 		};
 	}
 
@@ -247,43 +256,7 @@ export class PgSetOperator<
 	}
 
 	override getSQL(): SQL<unknown> {
-		const leftChunk = sql`(${this.leftSelect.getSQL()}) `;
-		const rightChunk = sql`(${this.rightSelect.getSQL()})`;
-
-		let orderBySql;
-		if (this.config.orderBy && this.config.orderBy.length > 0) {
-			const orderByValues: SQL<unknown>[] = [];
-
-			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
-			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
-			for (const orderBy of this.config.orderBy) {
-				if (is(orderBy, PgColumn)) {
-					orderByValues.push(sql.raw(orderBy.name));
-				} else if (is(orderBy, SQL)) {
-					for (let i = 0; i < orderBy.queryChunks.length; i++) {
-						const chunk = orderBy.queryChunks[i];
-
-						if (is(chunk, PgColumn)) {
-							orderBy.queryChunks[i] = sql.raw(chunk.name);
-						}
-					}
-
-					orderByValues.push(sql`${orderBy}`);
-				} else {
-					orderByValues.push(sql`${orderBy}`);
-				}
-			}
-
-			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
-		}
-
-		const limitSql = this.config.limit ? sql` limit ${this.config.limit}` : undefined;
-
-		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
-
-		const offsetSql = this.config.offset ? sql` offset ${this.config.offset}` : undefined;
-
-		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+		return this.dialect.buildSetOperationQuery(this.config);
 	}
 
 	private _prepare(name?: string): PreparedQuery<
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index cc59b3a2b..6bbefcdc3 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -18,7 +18,12 @@ import {
 } from '~/relations.ts';
 import { and, eq, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
 import { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
-import type { SQLiteDeleteConfig, SQLiteInsertConfig, SQLiteUpdateConfig } from '~/sqlite-core/query-builders/index.ts';
+import type {
+	SQLiteDeleteConfig,
+	SQLiteInsertConfig,
+	SQLiteSetOperationConfig,
+	SQLiteUpdateConfig,
+} from '~/sqlite-core/query-builders/index.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
@@ -272,6 +277,54 @@ export abstract class SQLiteDialect {
 		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;
 	}
 
+	buildSetOperationQuery({
+		operator,
+		isAll,
+		leftSelect,
+		rightSelect,
+		limit,
+		orderBy,
+		offset,
+	}: SQLiteSetOperationConfig): SQL {
+		const leftChunk = sql`${leftSelect.getSQL()} `;
+		const rightChunk = sql`${rightSelect.getSQL()}`;
+
+		let orderBySql;
+		if (orderBy && orderBy.length > 0) {
+			const orderByValues: SQL<unknown>[] = [];
+
+			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
+			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			for (const singleOrderBy of orderBy) {
+				if (is(singleOrderBy, SQLiteColumn)) {
+					orderByValues.push(sql.raw(singleOrderBy.name));
+				} else if (is(singleOrderBy, SQL)) {
+					for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {
+						const chunk = singleOrderBy.queryChunks[i];
+
+						if (is(chunk, SQLiteColumn)) {
+							singleOrderBy.queryChunks[i] = sql.raw(chunk.name);
+						}
+					}
+
+					orderByValues.push(sql`${singleOrderBy}`);
+				} else {
+					orderByValues.push(sql`${singleOrderBy}`);
+				}
+			}
+
+			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)}`;
+		}
+
+		const limitSql = limit ? sql` limit ${limit}` : undefined;
+
+		const operatorChunk = sql.raw(`${operator} ${isAll ? 'all ' : ''}`);
+
+		const offsetSql = offset ? sql` offset ${offset}` : undefined;
+
+		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+	}
+
 	buildInsertQuery({ table, values, onConflict, returning }: SQLiteInsertConfig): SQL {
 		// const isSingleValue = values.length === 1;
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index 85d6e1589..91e85bb36 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -1,11 +1,10 @@
-import { entityKind, is } from '~/entity.ts';
+import { entityKind } from '~/entity.ts';
 import {
 	orderSelectedFields,
 	type Placeholder,
 	type Query,
 	SelectionProxyHandler,
-	SQL,
-	sql,
+	type SQL,
 	Subquery,
 	type ValueOrArray,
 } from '~/index.ts';
@@ -19,8 +18,8 @@ import type {
 import { QueryPromise } from '~/query-promise.ts';
 import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { applyMixins, haveSameKeys, type PromiseOf, type ValidateShape } from '~/utils.ts';
-import { type ColumnsSelection } from '~/view.ts';
-import { SQLiteColumn } from '../columns/common.ts';
+import type { ColumnsSelection } from '~/view.ts';
+import type { SQLiteColumn } from '../columns/common.ts';
 import type { SQLiteDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
 import type { SQLiteSelectHKTBase } from './select.types.ts';
@@ -63,6 +62,17 @@ type SetOperatorRestSelect<
 	: never[]
 	: TValue;
 
+export interface SQLiteSetOperationConfig {
+	fields: Record<string, unknown>;
+	operator: SetOperator;
+	isAll: boolean;
+	leftSelect: SQLiteSetOperatorBuilder<any, any, any, any, any, any, any>;
+	rightSelect: TypedQueryBuilder<any, any[]>;
+	limit?: number | Placeholder;
+	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+	offset?: number | Placeholder;
+}
+
 export abstract class SQLiteSetOperatorBuilder<
 	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
@@ -176,20 +186,15 @@ export class SQLiteSetOperator<
 	static readonly [entityKind]: string = 'SQLiteSetOperator';
 
 	protected joinsNotNullableMap: Record<string, boolean>;
-	protected config: {
-		fields: Record<string, unknown>;
-		limit?: number | Placeholder;
-		orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
-		offset?: number | Placeholder;
-	};
+	protected config: SQLiteSetOperationConfig;
 	/* @internal */
 	readonly session: SQLiteSession<any, any, any, any> | undefined;
 	protected dialect: SQLiteDialect;
 
 	constructor(
-		private operator: SetOperator,
-		private isAll: boolean,
-		private leftSelect: SQLiteSetOperatorBuilder<
+		operator: SetOperator,
+		isAll: boolean,
+		leftSelect: SQLiteSetOperatorBuilder<
 			THKT,
 			TTableName,
 			TResultType,
@@ -198,7 +203,7 @@ export class SQLiteSetOperator<
 			TSelectMode,
 			TNullabilityMap
 		>,
-		private rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
 		super();
 
@@ -222,6 +227,10 @@ export class SQLiteSetOperator<
 		this.joinsNotNullableMap = joinsNotNullableMap;
 		this.config = {
 			fields,
+			operator,
+			isAll,
+			leftSelect,
+			rightSelect,
 		};
 	}
 
@@ -262,43 +271,7 @@ export class SQLiteSetOperator<
 	}
 
 	override getSQL(): SQL<unknown> {
-		const leftChunk = sql`${this.leftSelect.getSQL()} `;
-		const rightChunk = sql`${this.rightSelect.getSQL()}`;
-
-		let orderBySql;
-		if (this.config.orderBy && this.config.orderBy.length > 0) {
-			const orderByValues: SQL<unknown>[] = [];
-
-			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
-			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
-			for (const orderBy of this.config.orderBy) {
-				if (is(orderBy, SQLiteColumn)) {
-					orderByValues.push(sql.raw(orderBy.name));
-				} else if (is(orderBy, SQL)) {
-					for (let i = 0; i < orderBy.queryChunks.length; i++) {
-						const chunk = orderBy.queryChunks[i];
-
-						if (is(chunk, SQLiteColumn)) {
-							orderBy.queryChunks[i] = sql.raw(chunk.name);
-						}
-					}
-
-					orderByValues.push(sql`${orderBy}`);
-				} else {
-					orderByValues.push(sql`${orderBy}`);
-				}
-			}
-
-			orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)}`;
-		}
-
-		const limitSql = this.config.limit ? sql` limit ${this.config.limit}` : undefined;
-
-		const operatorChunk = sql.raw(`${this.operator} ${this.isAll ? 'all ' : ''}`);
-
-		const offsetSql = this.config.offset ? sql` offset ${this.config.offset}` : undefined;
-
-		return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+		return this.dialect.buildSetOperationQuery(this.config);
 	}
 
 	prepare(isOneTimeQuery?: boolean): PreparedQuery<

From b349f569013d29f0f74d034b94336c85e04294ec Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Thu, 28 Sep 2023 13:38:40 +0300
Subject: [PATCH 30/72] Fix PK's generation

---
 drizzle-orm/src/mysql-core/primary-keys.ts      | 4 ++--
 drizzle-orm/src/pg-core/primary-keys.ts         | 4 ++--
 drizzle-orm/src/sqlite-core/primary-keys.ts     | 4 ++--
 integration-tests/tests/relational/pg.schema.ts | 2 +-
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/primary-keys.ts b/drizzle-orm/src/mysql-core/primary-keys.ts
index cb43e8351..048293a51 100644
--- a/drizzle-orm/src/mysql-core/primary-keys.ts
+++ b/drizzle-orm/src/mysql-core/primary-keys.ts
@@ -15,8 +15,8 @@ export function primaryKey<
 	TTableName extends string,
 	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>[],
 >(...columns: TColumns): PrimaryKeyBuilder;
-export function primaryKey(config: any) {
-	if (config.name) {
+export function primaryKey(...config: any) {
+	if (config.columns) {
 		return new PrimaryKeyBuilder(config.columns, config.name);
 	}
 	return new PrimaryKeyBuilder(config);
diff --git a/drizzle-orm/src/pg-core/primary-keys.ts b/drizzle-orm/src/pg-core/primary-keys.ts
index b9364c6ef..2d8684972 100644
--- a/drizzle-orm/src/pg-core/primary-keys.ts
+++ b/drizzle-orm/src/pg-core/primary-keys.ts
@@ -15,8 +15,8 @@ export function primaryKey<
 	TTableName extends string,
 	TColumns extends AnyPgColumn<{ tableName: TTableName }>[],
 >(...columns: TColumns): PrimaryKeyBuilder;
-export function primaryKey(config: any) {
-	if (config.name) {
+export function primaryKey(...config: any) {
+	if (config.columns) {
 		return new PrimaryKeyBuilder(config.columns, config.name);
 	}
 	return new PrimaryKeyBuilder(config);
diff --git a/drizzle-orm/src/sqlite-core/primary-keys.ts b/drizzle-orm/src/sqlite-core/primary-keys.ts
index 1d73d6461..02517c55e 100644
--- a/drizzle-orm/src/sqlite-core/primary-keys.ts
+++ b/drizzle-orm/src/sqlite-core/primary-keys.ts
@@ -15,8 +15,8 @@ export function primaryKey<
 	TTableName extends string,
 	TColumns extends AnySQLiteColumn<{ tableName: TTableName }>[],
 >(...columns: TColumns): PrimaryKeyBuilder;
-export function primaryKey(config: any) {
-	if (config.name) {
+export function primaryKey(...config: any) {
+	if (config.columns) {
 		return new PrimaryKeyBuilder(config.columns, config.name);
 	}
 	return new PrimaryKeyBuilder(config);
diff --git a/integration-tests/tests/relational/pg.schema.ts b/integration-tests/tests/relational/pg.schema.ts
index b17bafa60..05f06aaa1 100644
--- a/integration-tests/tests/relational/pg.schema.ts
+++ b/integration-tests/tests/relational/pg.schema.ts
@@ -30,7 +30,7 @@ export const usersToGroupsTable = pgTable('users_to_groups', {
 	userId: integer('user_id').notNull().references(() => usersTable.id),
 	groupId: integer('group_id').notNull().references(() => groupsTable.id),
 }, (t) => ({
-	pk: primaryKey(t.userId, t.groupId),
+	pk: primaryKey(t.groupId,t.userId),
 }));
 
 export const usersToGroupsConfig = relations(usersToGroupsTable, ({ one }) => ({

From 4e094f03aa9b7de46490655fa80d38b3679f8c15 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Thu, 28 Sep 2023 14:02:20 +0300
Subject: [PATCH 31/72] Fix PK's composite for new syntax

---
 drizzle-orm/src/mysql-core/primary-keys.ts  | 4 ++--
 drizzle-orm/src/pg-core/primary-keys.ts     | 4 ++--
 drizzle-orm/src/sqlite-core/primary-keys.ts | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/primary-keys.ts b/drizzle-orm/src/mysql-core/primary-keys.ts
index 048293a51..014cbd8c0 100644
--- a/drizzle-orm/src/mysql-core/primary-keys.ts
+++ b/drizzle-orm/src/mysql-core/primary-keys.ts
@@ -16,8 +16,8 @@ export function primaryKey<
 	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>[],
 >(...columns: TColumns): PrimaryKeyBuilder;
 export function primaryKey(...config: any) {
-	if (config.columns) {
-		return new PrimaryKeyBuilder(config.columns, config.name);
+	if (config[0].columns) {
+		return new PrimaryKeyBuilder(config[0].columns, config[0].name);
 	}
 	return new PrimaryKeyBuilder(config);
 }
diff --git a/drizzle-orm/src/pg-core/primary-keys.ts b/drizzle-orm/src/pg-core/primary-keys.ts
index 2d8684972..7e2f84be1 100644
--- a/drizzle-orm/src/pg-core/primary-keys.ts
+++ b/drizzle-orm/src/pg-core/primary-keys.ts
@@ -16,8 +16,8 @@ export function primaryKey<
 	TColumns extends AnyPgColumn<{ tableName: TTableName }>[],
 >(...columns: TColumns): PrimaryKeyBuilder;
 export function primaryKey(...config: any) {
-	if (config.columns) {
-		return new PrimaryKeyBuilder(config.columns, config.name);
+	if (config[0].columns) {
+		return new PrimaryKeyBuilder(config[0].columns, config[0].name);
 	}
 	return new PrimaryKeyBuilder(config);
 }
diff --git a/drizzle-orm/src/sqlite-core/primary-keys.ts b/drizzle-orm/src/sqlite-core/primary-keys.ts
index 02517c55e..1ca1c0145 100644
--- a/drizzle-orm/src/sqlite-core/primary-keys.ts
+++ b/drizzle-orm/src/sqlite-core/primary-keys.ts
@@ -16,8 +16,8 @@ export function primaryKey<
 	TColumns extends AnySQLiteColumn<{ tableName: TTableName }>[],
 >(...columns: TColumns): PrimaryKeyBuilder;
 export function primaryKey(...config: any) {
-	if (config.columns) {
-		return new PrimaryKeyBuilder(config.columns, config.name);
+	if (config[0].columns) {
+		return new PrimaryKeyBuilder(config[0].columns, config[0].name);
 	}
 	return new PrimaryKeyBuilder(config);
 }

From ee6a68b2c7e6c642ad36d25ea129a1828f35d164 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Sat, 30 Sep 2023 23:34:19 +0300
Subject: [PATCH 32/72] Improve query builder types, update batch API

---
 .eslintignore                                 |   1 +
 .eslintrc.yaml                                |   1 +
 drizzle-orm/src/batch.ts                      |  35 +-
 drizzle-orm/src/better-sqlite3/session.ts     |  27 +-
 drizzle-orm/src/bun-sqlite/session.ts         |  27 +-
 drizzle-orm/src/d1/driver.ts                  |  14 +-
 drizzle-orm/src/d1/session.ts                 | 256 ++++++----
 drizzle-orm/src/errors.ts                     |  11 +-
 drizzle-orm/src/libsql/driver.ts              |  12 +-
 drizzle-orm/src/libsql/session.ts             | 218 ++++----
 drizzle-orm/src/mysql-core/db.ts              |  10 +-
 drizzle-orm/src/mysql-core/dialect.ts         |  13 +-
 .../src/mysql-core/query-builders/delete.ts   |  84 +++-
 .../src/mysql-core/query-builders/insert.ts   | 101 +++-
 .../query-builders/query-builder.ts           |  12 +-
 .../src/mysql-core/query-builders/select.ts   | 167 +++---
 .../mysql-core/query-builders/select.types.ts | 184 +++++--
 .../src/mysql-core/query-builders/update.ts   |  92 +++-
 drizzle-orm/src/mysql-core/session.ts         |   4 +
 drizzle-orm/src/mysql-core/subquery.ts        |  11 +-
 drizzle-orm/src/mysql2/driver.ts              |   7 +-
 drizzle-orm/src/pg-core/db.ts                 |   6 +-
 drizzle-orm/src/pg-core/dialect.ts            |  38 +-
 .../src/pg-core/query-builders/delete.ts      | 121 ++++-
 .../src/pg-core/query-builders/insert.ts      | 141 ++++--
 .../src/pg-core/query-builders/select.ts      | 186 ++++---
 .../pg-core/query-builders/select.types.ts    | 186 +++++--
 .../src/pg-core/query-builders/update.ts      | 134 +++--
 .../src/query-builders/select.types.ts        |  10 +-
 drizzle-orm/src/runnable-query.ts             |  11 +
 drizzle-orm/src/session.ts                    |   6 +
 drizzle-orm/src/sql-js/session.ts             |  30 +-
 drizzle-orm/src/sqlite-core/db.ts             |  64 ++-
 drizzle-orm/src/sqlite-core/dialect.ts        |  15 +-
 .../src/sqlite-core/query-builders/delete.ts  | 161 ++++--
 .../src/sqlite-core/query-builders/insert.ts  | 184 +++++--
 .../query-builders/query-builder.ts           |   4 +-
 .../src/sqlite-core/query-builders/query.ts   |  17 +-
 .../src/sqlite-core/query-builders/raw.ts     |  27 +-
 .../src/sqlite-core/query-builders/select.ts  | 171 ++++---
 .../query-builders/select.types.ts            | 226 +++++++--
 .../src/sqlite-core/query-builders/update.ts  | 173 +++++--
 drizzle-orm/src/sqlite-core/session.ts        |  99 ++--
 drizzle-orm/src/sqlite-proxy/session.ts       |  37 +-
 drizzle-orm/src/table.ts                      |  21 +-
 drizzle-orm/src/version.ts                    |   2 +-
 drizzle-orm/tests/tsconfig.json               |   6 +-
 drizzle-orm/tsconfig.build.json               |   2 -
 drizzle-orm/tsconfig.cjs.json                 |   2 -
 drizzle-orm/type-tests/mysql/delete.ts        |  27 +
 drizzle-orm/type-tests/mysql/insert.ts        |  22 +-
 drizzle-orm/type-tests/mysql/select.ts        | 171 +++++++
 drizzle-orm/type-tests/mysql/update.ts        |  26 +
 drizzle-orm/type-tests/pg/delete.ts           |  38 ++
 drizzle-orm/type-tests/pg/insert.ts           |  32 ++
 drizzle-orm/type-tests/pg/select.ts           | 205 +++++++-
 drizzle-orm/type-tests/pg/update.ts           |  40 ++
 drizzle-orm/type-tests/sqlite/delete.ts       |  38 ++
 drizzle-orm/type-tests/sqlite/insert.ts       |  34 ++
 drizzle-orm/type-tests/sqlite/select.ts       | 141 ++++++
 drizzle-orm/type-tests/sqlite/update.ts       |  40 ++
 drizzle-orm/type-tests/tsconfig.json          |   5 +-
 integration-tests/tests/awsdatapi.test.ts     |   4 +-
 integration-tests/tests/better-sqlite.test.ts |  16 +-
 integration-tests/tests/d1.test.ts            |  16 +-
 integration-tests/tests/libsql-batch.test.ts  |   5 +-
 integration-tests/tests/libsql.test.ts        |  16 +-
 .../tests/mysql.prefixed.test.ts              |   4 +-
 integration-tests/tests/mysql.test.ts         |   4 +-
 integration-tests/tests/neon-http.test.ts     | 105 +++-
 integration-tests/tests/pg.test.ts            | 105 +++-
 .../planetscale-serverless/mysql.test.ts      |   4 +-
 integration-tests/tests/postgres.js.test.ts   | 105 +++-
 integration-tests/tests/sql.js.test.ts        |   4 +-
 integration-tests/tests/vercel-pg.test.ts     | 105 +++-
 integration-tests/tsconfig.json               |   7 +-
 output.txt                                    |  62 +++
 package.json                                  |  20 +-
 ...ipt@5.1.6.patch => typescript@5.2.2.patch} |   6 +-
 pnpm-lock.yaml                                | 474 ++++++++++--------
 tsconfig.json                                 |   5 +-
 81 files changed, 3771 insertions(+), 1482 deletions(-)
 create mode 100644 drizzle-orm/src/runnable-query.ts
 create mode 100644 drizzle-orm/src/session.ts
 create mode 100644 drizzle-orm/type-tests/mysql/update.ts
 create mode 100644 output.txt
 rename patches/{typescript@5.1.6.patch => typescript@5.2.2.patch} (65%)

diff --git a/.eslintignore b/.eslintignore
index 94ac4254b..d88c5d722 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -5,3 +5,4 @@ examples
 **/*.js
 **/*.mjs
 **/*.cjs
+**/playground
diff --git a/.eslintrc.yaml b/.eslintrc.yaml
index 7af1bd426..5c26b2a2b 100644
--- a/.eslintrc.yaml
+++ b/.eslintrc.yaml
@@ -66,3 +66,4 @@ rules:
   '@typescript-eslint/ban-ts-comment': 'off'
   '@typescript-eslint/no-empty-interface': 'off'
   '@typescript-eslint/no-unsafe-declaration-merging': 'off'
+  'no-inner-declarations': 'off'
diff --git a/drizzle-orm/src/batch.ts b/drizzle-orm/src/batch.ts
index 72284914d..0931440a5 100644
--- a/drizzle-orm/src/batch.ts
+++ b/drizzle-orm/src/batch.ts
@@ -1,33 +1,8 @@
-import type { SelectResult } from './query-builders/select.types.ts';
-import type { SQLiteDelete, SQLiteInsert, SQLiteSelect, SQLiteUpdate } from './sqlite-core/index.ts';
-import type { SQLiteRelationalQuery } from './sqlite-core/query-builders/query.ts';
-import type { SQLiteRaw } from './sqlite-core/query-builders/raw.ts';
+import type { Dialect } from './column-builder.ts';
+import type { RunnableQuery } from './runnable-query.ts';
 
-export type BatchParameters<TDriverResult = any> =
-	| SQLiteUpdate<any, 'async', TDriverResult, any>
-	| SQLiteSelect<any, 'async', TDriverResult, any, any>
-	| SQLiteDelete<any, 'async', TDriverResult, any>
-	| Omit<SQLiteDelete<any, 'async', TDriverResult, any>, 'where'>
-	| Omit<SQLiteUpdate<any, 'async', TDriverResult, any>, 'where'>
-	| SQLiteInsert<any, 'async', TDriverResult, any>
-	| SQLiteRelationalQuery<'async', any>
-	| SQLiteRaw<any>;
+export type BatchItem<TDialect extends Dialect = Dialect> = RunnableQuery<any, TDialect>;
 
-export type BatchResponse<U extends BatchParameters, TQuery extends Readonly<[U, ...U[]]>> = {
-	[K in keyof TQuery]: TQuery[K] extends
-		SQLiteSelect<infer _TTable, 'async', infer _TRes, infer TSelection, infer TSelectMode, infer TNullabilityMap>
-		? SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-		: TQuery[K] extends SQLiteUpdate<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends Omit<SQLiteUpdate<infer _TTable, 'async', infer _TRunResult, infer _TReturning>, 'where'>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends SQLiteInsert<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends SQLiteDelete<infer _TTable, 'async', infer _TRunResult, infer _TReturning>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends Omit<SQLiteDelete<infer _TTable, 'async', infer _TRunResult, infer _TReturning>, 'where'>
-			? _TReturning extends undefined ? _TRunResult : _TReturning[]
-		: TQuery[K] extends SQLiteRelationalQuery<'async', infer TResult> ? TResult
-		: TQuery[K] extends SQLiteRaw<infer TResult> ? TResult
-		: never;
+export type BatchResponse<T extends BatchItem[] | readonly BatchItem[]> = {
+	[K in keyof T]: T[K]['_']['result'];
 };
diff --git a/drizzle-orm/src/better-sqlite3/session.ts b/drizzle-orm/src/better-sqlite3/session.ts
index 74be6830b..a93ea74c8 100644
--- a/drizzle-orm/src/better-sqlite3/session.ts
+++ b/drizzle-orm/src/better-sqlite3/session.ts
@@ -8,9 +8,9 @@ import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
 import {
-	PreparedQuery as PreparedQueryBase,
 	type PreparedQueryConfig as PreparedQueryConfigBase,
 	type SQLiteExecuteMethod,
+	SQLitePreparedQuery as PreparedQueryBase,
 	SQLiteSession,
 	type SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
@@ -47,7 +47,7 @@ export class BetterSQLiteSession<
 		customResultMapper?: (rows: unknown[][]) => unknown,
 	): PreparedQuery<T> {
 		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(stmt, query.sql, query.params, this.logger, fields, executeMethod, customResultMapper);
+		return new PreparedQuery(stmt, query, this.logger, fields, executeMethod, customResultMapper);
 	}
 
 	override transaction<T>(
@@ -88,27 +88,26 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 
 	constructor(
 		private stmt: Statement,
-		private queryString: string,
-		private params: unknown[],
+		query: Query,
 		private logger: Logger,
 		private fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 		private customResultMapper?: (rows: unknown[][]) => unknown,
 	) {
-		super('sync', executeMethod);
+		super('sync', executeMethod, query);
 	}
 
 	run(placeholderValues?: Record<string, unknown>): RunResult {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		return this.stmt.run(...params);
 	}
 
 	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const { fields, joinsNotNullableMap, queryString, logger, stmt, customResultMapper } = this;
+		const { fields, joinsNotNullableMap, query, logger, stmt, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(this.params, placeholderValues ?? {});
-			logger.logQuery(queryString, params);
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
 			return stmt.all(...params);
 		}
 
@@ -120,8 +119,8 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 
 		const { fields, stmt, joinsNotNullableMap, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
@@ -142,8 +141,8 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		return this.stmt.raw().all(...params) as T['values'];
 	}
 }
diff --git a/drizzle-orm/src/bun-sqlite/session.ts b/drizzle-orm/src/bun-sqlite/session.ts
index 816b1ab06..009663123 100644
--- a/drizzle-orm/src/bun-sqlite/session.ts
+++ b/drizzle-orm/src/bun-sqlite/session.ts
@@ -14,7 +14,7 @@ import type {
 	SQLiteExecuteMethod,
 	SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
-import { PreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
+import { SQLitePreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
 
 export interface SQLiteBunSessionOptions {
@@ -53,7 +53,7 @@ export class SQLiteBunSession<
 		customResultMapper?: (rows: unknown[][]) => unknown,
 	): PreparedQuery<T> {
 		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(stmt, query.sql, query.params, this.logger, fields, executeMethod, customResultMapper);
+		return new PreparedQuery(stmt, query, this.logger, fields, executeMethod, customResultMapper);
 	}
 
 	override transaction<T>(
@@ -98,27 +98,26 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 
 	constructor(
 		private stmt: Statement,
-		private queryString: string,
-		private params: unknown[],
+		query: Query,
 		private logger: Logger,
 		private fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 		private customResultMapper?: (rows: unknown[][]) => unknown,
 	) {
-		super('sync', executeMethod);
+		super('sync', executeMethod, query);
 	}
 
 	run(placeholderValues?: Record<string, unknown>): void {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		return this.stmt.run(...params);
 	}
 
 	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const { fields, queryString, logger, joinsNotNullableMap, stmt, customResultMapper } = this;
+		const { fields, query, logger, joinsNotNullableMap, stmt, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(this.params, placeholderValues ?? {});
-			logger.logQuery(queryString, params);
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
 			return stmt.all(...params);
 		}
 
@@ -132,8 +131,8 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		const row = this.stmt.get(...params);
 
 		if (!row) {
@@ -153,8 +152,8 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		return this.stmt.values(...params);
 	}
 }
diff --git a/drizzle-orm/src/d1/driver.ts b/drizzle-orm/src/d1/driver.ts
index 2ba156b61..628ada725 100644
--- a/drizzle-orm/src/d1/driver.ts
+++ b/drizzle-orm/src/d1/driver.ts
@@ -1,8 +1,11 @@
 /// <reference types="@cloudflare/workers-types" />
+import type { BatchItem, BatchResponse } from '~/batch.ts';
+import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
 import {
 	createTableRelationsHelpers,
 	extractTablesRelationalConfig,
+	type ExtractTablesWithRelations,
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
@@ -10,18 +13,19 @@ import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { type DrizzleConfig } from '~/utils.ts';
 import { SQLiteD1Session } from './session.ts';
-import { entityKind } from '~/entity.ts';
-import type { BatchParameters, BatchResponse } from '~/batch.ts';
 
 export class DrizzleD1Database<
 	TSchema extends Record<string, unknown> = Record<string, never>,
 > extends BaseSQLiteDatabase<'async', D1Result, TSchema> {
 	static readonly [entityKind]: string = 'LibSQLDatabase';
 
-	async batch<U extends BatchParameters<D1Result>, T extends Readonly<[U, ...U[]]>>(
+	/** @internal */
+	declare readonly session: SQLiteD1Session<TSchema, ExtractTablesWithRelations<TSchema>>;
+
+	async batch<U extends BatchItem<'sqlite'>, T extends Readonly<[U, ...U[]]>>(
 		batch: T,
-	): Promise<BatchResponse<U, T>> {
-		return await (this.session as SQLiteD1Session<TSchema, any>).batch(batch) as BatchResponse<U, T>;
+	): Promise<BatchResponse<T>> {
+		return this.session.batch(batch) as Promise<BatchResponse<T>>;
 	}
 }
 
diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index bfdfc9d60..6adf3de73 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -1,24 +1,22 @@
 /// <reference types="@cloudflare/workers-types" />
 
-import type { BatchParameters } from '~/batch.ts';
-import { entityKind, is } from '~/entity.ts';
-import { DrizzleError } from '~/errors.ts';
+import type { BatchItem } from '~/batch.ts';
+import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { PreparedQuery } from '~/session.ts';
 import { type Query, sql } from '~/sql/index.ts';
 import { fillPlaceholders } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteDelete, SQLiteInsert, SQLiteSelect, SQLiteTransaction, SQLiteUpdate } from '~/sqlite-core/index.ts';
-import { SQLiteRelationalQuery } from '~/sqlite-core/query-builders/query.ts';
-import { SQLiteRaw } from '~/sqlite-core/query-builders/raw.ts';
+import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
 import {
 	type PreparedQueryConfig as PreparedQueryConfigBase,
 	type SQLiteExecuteMethod,
 	type SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
-import { PreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
+import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
 
 export interface SQLiteD1SessionOptions {
@@ -50,9 +48,9 @@ export class SQLiteD1Session<
 		fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 		customResultMapper?: (rows: unknown[][]) => unknown,
-	): PreparedQuery {
+	): D1PreparedQuery {
 		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(stmt, query.sql, query.params, this.logger, fields, executeMethod, customResultMapper);
+		return new D1PreparedQuery(stmt, query, this.logger, fields, executeMethod, customResultMapper);
 	}
 
 	/**
@@ -70,86 +68,99 @@ export class SQLiteD1Session<
 		return rows;
 	}
 
-	/*override */ batch<U extends BatchParameters, T extends Readonly<[U, ...U[]]>>(queries: T) {
-		const queryToType: (
-			| { mode: 'all' }
-			| {
-				mode: 'all_mapped';
-				config: { fields: SelectedFieldsOrdered; joinsNotNullableMap?: Record<string, boolean> };
-			}
-			| { mode: 'get' }
-			| { mode: 'values' }
-			| { mode: 'raw' }
-			| { mode: 'rqb'; mapper: any }
-		)[] = [];
-
-		const builtQueries: D1PreparedStatement[] = queries.map((query) => {
-			if (is(query, SQLiteSelect<any, 'async', any, any, any>)) {
-				const prepared = query.prepare() as PreparedQuery;
-				prepared.fields === undefined
-					? queryToType.push({ mode: 'all' })
-					: queryToType.push({
-						mode: 'all_mapped',
-						config: { fields: prepared.fields, joinsNotNullableMap: prepared.joinsNotNullableMap },
-					});
-				return prepared.stmt.bind(...prepared.params);
-			} else if (
-				is(query, SQLiteInsert<any, 'async', any, any>) || is(query, SQLiteUpdate<any, 'async', any, any>)
-				|| is(query, SQLiteDelete<any, 'async', any, any>)
-			) {
-				const prepared = query.prepare() as PreparedQuery;
-				queryToType.push(
-					query.config.returning
-						? {
-							mode: 'all_mapped',
-							config: { fields: query.config.returning },
-						}
-						: { mode: 'raw' },
-				);
-				return prepared.stmt.bind(...prepared.params);
-			} else if (is(query, SQLiteRaw)) {
-				const builtQuery = this.dialect.sqlToQuery(query.getSQL());
-				queryToType.push(
-					query.config.action === 'run' ? { mode: 'raw' } : { mode: query.config.action },
-				);
-				return this.client.prepare(builtQuery.sql).bind(...builtQuery.params);
-			} else if (is(query, SQLiteRelationalQuery)) {
-				const preparedRqb = query.prepare() as PreparedQuery;
-				queryToType.push({ mode: 'rqb', mapper: preparedRqb.customResultMapper });
-				return preparedRqb.stmt.bind(...preparedRqb.params);
-			}
-			throw new DrizzleError('You can use only drizzle queries in D1 batch api');
-		});
-
-		const res = this.client.batch<any>(builtQueries).then((stmt) =>
-			stmt.map(({ results }, index) => {
-				const action = queryToType[index]!;
-				if (action.mode === 'all') {
-					return results;
-				}
-				if (action.mode === 'all_mapped') {
-					const mappedRows = this.d1ToRawMapping(results);
-					return mappedRows!.map((row) => {
-						return mapResultRow(
-							action.config.fields,
-							row,
-							action.config.joinsNotNullableMap,
-						);
-					});
-				}
-				if (action.mode === 'get') {
-					return results[0] as unknown[];
-				}
-				if (action.mode === 'values') {
-					return this.d1ToRawMapping(results);
-				}
-				if (action.mode === 'raw') {
-					return stmt[index];
-				}
-				return action.mapper(this.d1ToRawMapping(results));
-			})
-		);
-		return res;
+	/*override */ async batch<U extends BatchItem, T extends Readonly<[U, ...U[]]>>(queries: T) {
+		const preparedQueries: PreparedQuery[] = [];
+		const builtQueries: D1PreparedStatement[] = [];
+
+		for (const query of queries) {
+			const preparedQuery = query.prepare();
+			const builtQuery = preparedQuery.getQuery();
+			preparedQueries.push(preparedQuery);
+			builtQueries.push((preparedQuery as D1PreparedQuery).stmt.bind(...builtQuery.params));
+		}
+
+		// const queryToType: (
+		// 	| { mode: 'all' }
+		// 	| {
+		// 		mode: 'all_mapped';
+		// 		config: { fields: SelectedFieldsOrdered; joinsNotNullableMap?: Record<string, boolean> };
+		// 	}
+		// 	| { mode: 'get' }
+		// 	| { mode: 'values' }
+		// 	| { mode: 'raw' }
+		// 	| { mode: 'rqb'; mapper: any }
+		// )[] = [];
+
+		// const builtQueries: D1PreparedStatement[] = queries.map((query) => {
+		// 	if (is(query, SQLiteSelectBase<any, 'async', any, any, any>)) {
+		// 		const prepared = query.prepare() as D1PreparedQuery;
+		// 		prepared.fields === undefined
+		// 			? queryToType.push({ mode: 'all' })
+		// 			: queryToType.push({
+		// 				mode: 'all_mapped',
+		// 				config: { fields: prepared.fields, joinsNotNullableMap: prepared.joinsNotNullableMap },
+		// 			});
+		// 		return prepared.stmt.bind(...prepared.params);
+		// 	} else if (
+		// 		is(query, SQLiteInsertBase<any, 'async', any, any>) || is(query, SQLiteUpdateBase<any, 'async', any, any>)
+		// 		|| is(query, SQLiteDeleteBase<any, 'async', any, any>)
+		// 	) {
+		// 		const prepared = query.prepare() as D1PreparedQuery;
+		// 		queryToType.push(
+		// 			query.config.returning
+		// 				? {
+		// 					mode: 'all_mapped',
+		// 					config: { fields: query.config.returning },
+		// 				}
+		// 				: { mode: 'raw' },
+		// 		);
+		// 		return prepared.stmt.bind(...prepared.params);
+		// 	} else if (is(query, SQLiteRaw)) {
+		// 		const builtQuery = this.dialect.sqlToQuery(query.getSQL());
+		// 		queryToType.push(
+		// 			query.config.action === 'run' ? { mode: 'raw' } : { mode: query.config.action },
+		// 		);
+		// 		return this.client.prepare(builtQuery.sql).bind(...builtQuery.params);
+		// 	} else if (is(query, SQLiteRelationalQuery)) {
+		// 		const preparedRqb = query.prepare() as D1PreparedQuery;
+		// 		queryToType.push({ mode: 'rqb', mapper: preparedRqb.customResultMapper });
+		// 		return preparedRqb.stmt.bind(...preparedRqb.params);
+		// 	}
+		// 	throw new DrizzleError({ message: 'You can use only drizzle queries in D1 batch API' });
+		// });
+
+		const batchResults = await this.client.batch<any>(builtQueries);
+		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true));
+
+		// const res = this.client.batch<any>(builtQueries).then((stmt) =>
+		// 	stmt.map(({ results }, index) => {
+		// 		const action = queryToType[index]!;
+		// 		if (action.mode === 'all') {
+		// 			return results;
+		// 		}
+		// 		if (action.mode === 'all_mapped') {
+		// 			const mappedRows = this.d1ToRawMapping(results);
+		// 			return mappedRows!.map((row) => {
+		// 				return mapResultRow(
+		// 					action.config.fields,
+		// 					row,
+		// 					action.config.joinsNotNullableMap,
+		// 				);
+		// 			});
+		// 		}
+		// 		if (action.mode === 'get') {
+		// 			return results![0] as unknown[];
+		// 		}
+		// 		if (action.mode === 'values') {
+		// 			return this.d1ToRawMapping(results);
+		// 		}
+		// 		if (action.mode === 'raw') {
+		// 			return stmt[index];
+		// 		}
+		// 		return action.mapper(this.d1ToRawMapping(results));
+		// 	})
+		// );
+		// return res;
 	}
 
 	override async transaction<T>(
@@ -190,7 +201,7 @@ export class D1Transaction<
 	}
 }
 
-export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<
+export class D1PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
 	{ type: 'async'; run: D1Result; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
 > {
 	static readonly [entityKind]: string = 'D1PreparedQuery';
@@ -201,56 +212,63 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	/** @internal */
 	fields?: SelectedFieldsOrdered;
 
-	/** @internal */
-	params: unknown[];
-
 	/** @internal */
 	stmt: D1PreparedStatement;
 
 	constructor(
 		stmt: D1PreparedStatement,
-		private queryString: string,
-		params: unknown[],
+		query: Query,
 		private logger: Logger,
 		fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 		customResultMapper?: (rows: unknown[][]) => unknown,
 	) {
-		super('async', executeMethod);
+		super('async', executeMethod, query);
 		this.customResultMapper = customResultMapper;
 		this.fields = fields;
 		this.stmt = stmt;
-		this.params = params;
 	}
 
 	run(placeholderValues?: Record<string, unknown>): Promise<D1Result> {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		return this.stmt.bind(...params).run();
 	}
 
 	async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const { fields, joinsNotNullableMap, queryString, logger, stmt, customResultMapper } = this;
+		const { fields, query, logger, stmt, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(this.params, placeholderValues ?? {});
-			logger.logQuery(queryString, params);
-			return stmt.bind(...params).all().then(({ results }) => results!);
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
+			return stmt.bind(...params).all().then(({ results }) => this.mapAllResult(results!));
 		}
 
 		const rows = await this.values(placeholderValues);
 
-		if (customResultMapper) {
-			return customResultMapper(rows) as T['all'];
+		return this.mapAllResult(rows);
+	}
+
+	override mapAllResult(rows: unknown[], isFromBatch?: boolean): unknown {
+		if (isFromBatch) {
+			throw new Error('TODO');
 		}
 
-		return rows.map((row) => mapResultRow(fields!, row, joinsNotNullableMap));
+		if (!this.fields && !this.customResultMapper) {
+			return rows;
+		}
+
+		if (this.customResultMapper) {
+			return this.customResultMapper(rows as unknown[][]);
+		}
+
+		return (rows as unknown[][]).map((row) => mapResultRow(this.fields!, row, this.joinsNotNullableMap));
 	}
 
 	async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-		const { fields, joinsNotNullableMap, queryString, logger, stmt, customResultMapper } = this;
+		const { fields, joinsNotNullableMap, query, logger, stmt, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(this.params, placeholderValues ?? {});
-			logger.logQuery(queryString, params);
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
 			return stmt.bind(...params).all().then(({ results }) => results![0]);
 		}
 
@@ -267,9 +285,25 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 		return mapResultRow(fields!, rows[0], joinsNotNullableMap);
 	}
 
+	override mapGetResult(result: unknown, isFromBatch?: boolean): unknown {
+		if (isFromBatch) {
+			throw new Error('TODO');
+		}
+
+		if (!this.fields && !this.customResultMapper) {
+			return result;
+		}
+
+		if (this.customResultMapper) {
+			return this.customResultMapper([result as unknown[]]) as T['all'];
+		}
+
+		return mapResultRow(this.fields!, result as unknown[], this.joinsNotNullableMap);
+	}
+
 	values<T extends any[] = unknown[]>(placeholderValues?: Record<string, unknown>): Promise<T[]> {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		return this.stmt.bind(...params).raw();
 	}
 }
diff --git a/drizzle-orm/src/errors.ts b/drizzle-orm/src/errors.ts
index 151264c68..ede6e0a59 100644
--- a/drizzle-orm/src/errors.ts
+++ b/drizzle-orm/src/errors.ts
@@ -3,15 +3,10 @@ import { entityKind } from '~/entity.ts';
 export class DrizzleError extends Error {
 	static readonly [entityKind]: string = 'DrizzleError';
 
-	constructor(message: string) {
+	constructor({ message, cause }: { message?: string; cause?: unknown }) {
 		super(message);
 		this.name = 'DrizzleError';
-	}
-
-	static wrap(error: unknown, message?: string): DrizzleError {
-		return error instanceof Error // eslint-disable-line no-instanceof/no-instanceof
-			? new DrizzleError(message ? `${message}: ${error.message}` : error.message)
-			: new DrizzleError(message ?? String(error));
+		this.cause = cause;
 	}
 }
 
@@ -19,6 +14,6 @@ export class TransactionRollbackError extends DrizzleError {
 	static readonly [entityKind]: string = 'TransactionRollbackError';
 
 	constructor() {
-		super('Rollback');
+		super({ message: 'Rollback' });
 	}
 }
diff --git a/drizzle-orm/src/libsql/driver.ts b/drizzle-orm/src/libsql/driver.ts
index 44480f9f9..fc3d41ca7 100644
--- a/drizzle-orm/src/libsql/driver.ts
+++ b/drizzle-orm/src/libsql/driver.ts
@@ -1,9 +1,11 @@
 import type { Client, ResultSet } from '@libsql/client';
+import type { BatchItem, BatchResponse } from '~/batch.ts';
 import { entityKind } from '~/entity.ts';
 import { DefaultLogger } from '~/logger.ts';
 import {
 	createTableRelationsHelpers,
 	extractTablesRelationalConfig,
+	type ExtractTablesWithRelations,
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
@@ -11,17 +13,19 @@ import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { type DrizzleConfig } from '~/utils.ts';
 import { LibSQLSession } from './session.ts';
-import type { BatchParameters, BatchResponse } from '~/batch.ts';
 
 export class LibSQLDatabase<
 	TSchema extends Record<string, unknown> = Record<string, never>,
 > extends BaseSQLiteDatabase<'async', ResultSet, TSchema> {
 	static readonly [entityKind]: string = 'LibSQLDatabase';
 
-	async batch<U extends BatchParameters<ResultSet>, T extends Readonly<[U, ...U[]]>>(
+	/** @internal */
+	declare readonly session: LibSQLSession<TSchema, ExtractTablesWithRelations<TSchema>>;
+
+	async batch<U extends BatchItem<'sqlite'>, T extends Readonly<[U, ...U[]]>>(
 		batch: T,
-	): Promise<BatchResponse<U, T>> {
-		return await (this.session as LibSQLSession<TSchema, any>).batch(batch) as BatchResponse<U, T>;
+	): Promise<BatchResponse<T>> {
+		return this.session.batch(batch) as Promise<BatchResponse<T>>;
 	}
 }
 
diff --git a/drizzle-orm/src/libsql/session.ts b/drizzle-orm/src/libsql/session.ts
index fadb91b6c..bd6658943 100644
--- a/drizzle-orm/src/libsql/session.ts
+++ b/drizzle-orm/src/libsql/session.ts
@@ -1,21 +1,20 @@
 import { type Client, type InArgs, type InStatement, type ResultSet, type Transaction } from '@libsql/client';
-import type { BatchParameters } from '~/batch.ts';
-import { entityKind, is } from '~/entity.ts';
+import type { BatchItem as BatchItem } from '~/batch.ts';
+import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { PreparedQuery } from '~/session.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { SQLiteDelete, SQLiteInsert, SQLiteSelect, SQLiteTransaction, SQLiteUpdate } from '~/sqlite-core/index.ts';
-import { SQLiteRelationalQuery } from '~/sqlite-core/query-builders/query.ts';
-import { SQLiteRaw } from '~/sqlite-core/query-builders/raw.ts';
+import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
 import {
 	type PreparedQueryConfig as PreparedQueryConfigBase,
 	type SQLiteExecuteMethod,
 	type SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
-import { PreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
+import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
 
 export interface LibSQLSessionOptions {
@@ -48,11 +47,10 @@ export class LibSQLSession<
 		fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 		customResultMapper?: (rows: unknown[][]) => unknown,
-	): PreparedQuery<T> {
-		return new PreparedQuery(
+	): LibSQLPreparedQuery<T> {
+		return new LibSQLPreparedQuery(
 			this.client,
-			query.sql,
-			query.params,
+			query,
 			this.logger,
 			fields,
 			this.tx,
@@ -61,83 +59,19 @@ export class LibSQLSession<
 		);
 	}
 
-	/*override */ batch<U extends BatchParameters, T extends Readonly<[U, ...U[]]>>(queries: T) {
-		const queryToType: (
-			| { mode: 'all' }
-			| {
-				mode: 'all_mapped';
-				config: { fields: SelectedFieldsOrdered; joinsNotNullableMap?: Record<string, boolean> };
-			}
-			| { mode: 'get' }
-			| { mode: 'values' }
-			| { mode: 'raw' }
-			| { mode: 'rqb'; mapper: any }
-		)[] = [];
-
-		const builtQueries: InStatement[] = queries.map((query: BatchParameters) => {
-			const builtQuery = this.dialect.sqlToQuery(query.getSQL());
-
-			if (is(query, SQLiteSelect<any, 'async', any, any, any>)) {
-				const prepared = query.prepare() as PreparedQuery;
-				prepared.fields === undefined
-					? queryToType.push({ mode: 'all' })
-					: queryToType.push({
-						mode: 'all_mapped',
-						config: { fields: prepared.fields, joinsNotNullableMap: prepared.joinsNotNullableMap },
-					});
-			} else if (is(query, SQLiteRaw)) {
-				queryToType.push(
-					query.config.action === 'run' ? { mode: 'raw' } : { mode: query.config.action },
-				);
-			} else if (is(query, SQLiteRelationalQuery)) {
-				const preparedRqb = query.prepare() as PreparedQuery;
-				queryToType.push({ mode: 'rqb', mapper: preparedRqb.customResultMapper });
-			} else if (
-				is(query, SQLiteInsert<any, 'async', any, any>)
-				|| is(query, SQLiteUpdate<any, 'async', any, any>)
-				|| is(query, SQLiteDelete<any, 'async', any, any>)
-			) {
-				queryToType.push(
-					query.config.returning
-						? {
-							mode: 'all_mapped',
-							config: { fields: query.config.returning },
-						}
-						: { mode: 'raw' },
-				);
-			}
+	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T) {
+		const preparedQueries: PreparedQuery[] = [];
+		const builtQueries: InStatement[] = [];
 
-			return { sql: builtQuery.sql, args: builtQuery.params as InArgs };
-		});
+		for (const query of queries) {
+			const preparedQuery = query.prepare();
+			const builtQuery = preparedQuery.getQuery();
+			preparedQueries.push(preparedQuery);
+			builtQueries.push({ sql: builtQuery.sql, args: builtQuery.params as InArgs });
+		}
 
-		const res = this.client.batch(builtQueries).then((stmt) =>
-			stmt.map(({ rows }, index) => {
-				const action = queryToType[index]!;
-				if (action.mode === 'all') {
-					return rows.map((row) => normalizeRow(row));
-				}
-				if (action.mode === 'all_mapped') {
-					return rows.map((row) => {
-						return mapResultRow(
-							action.config.fields,
-							Array.prototype.slice.call(row).map((v) => normalizeFieldValue(v)),
-							action.config.joinsNotNullableMap,
-						);
-					});
-				}
-				if (action.mode === 'get') {
-					return normalizeRow(rows[0]);
-				}
-				if (action.mode === 'values') {
-					return rows.map((row) => Object.values(row));
-				}
-				if (action.mode === 'raw') {
-					return stmt[index];
-				}
-				return action.mapper(rows, normalizeFieldValue);
-			})
-		);
-		return res;
+		const batchResults = await this.client.batch(builtQueries);
+		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true));
 	}
 
 	override async transaction<T>(
@@ -157,6 +91,18 @@ export class LibSQLSession<
 			throw err;
 		}
 	}
+
+	override extractRawAllValueFromBatchResult(result: unknown): unknown {
+		return (result as ResultSet).rows;
+	}
+
+	override extractRawGetValueFromBatchResult(result: unknown): unknown {
+		return (result as ResultSet).rows[0];
+	}
+
+	override extractRawValuesValueFromBatchResult(result: unknown): unknown {
+		return (result as ResultSet).rows;
+	}
 }
 
 export class LibSQLTransaction<
@@ -180,93 +126,115 @@ export class LibSQLTransaction<
 	}
 }
 
-export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends PreparedQueryBase<
+export class LibSQLPreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
 	{ type: 'async'; run: ResultSet; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
 > {
 	static readonly [entityKind]: string = 'LibSQLPreparedQuery';
 
-	/** @internal */
-	customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown;
-
-	/** @internal */
-	fields?: SelectedFieldsOrdered;
-
 	constructor(
 		private client: Client,
-		private queryString: string,
-		private params: unknown[],
+		query: Query,
 		private logger: Logger,
-		fields: SelectedFieldsOrdered | undefined,
+		/** @internal */ public fields: SelectedFieldsOrdered | undefined,
 		private tx: Transaction | undefined,
 		executeMethod: SQLiteExecuteMethod,
-		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
+		/** @internal */ public customResultMapper?: (
+			rows: unknown[][],
+			mapColumnValue?: (value: unknown) => unknown,
+		) => unknown,
 	) {
-		super('async', executeMethod);
+		super('async', executeMethod, query);
 		this.customResultMapper = customResultMapper;
 		this.fields = fields;
 	}
 
 	run(placeholderValues?: Record<string, unknown>): Promise<ResultSet> {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
-		const stmt: InStatement = { sql: this.queryString, args: params as InArgs };
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		const stmt: InStatement = { sql: this.query.sql, args: params as InArgs };
 		return this.tx ? this.tx.execute(stmt) : this.client.execute(stmt);
 	}
 
 	async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const { fields, joinsNotNullableMap, logger, queryString, tx, client, customResultMapper } = this;
+		const { fields, logger, query, tx, client, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(this.params, placeholderValues ?? {});
-			logger.logQuery(queryString, params);
-			const stmt: InStatement = { sql: queryString, args: params as InArgs };
-			return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows }) => rows.map((row) => normalizeRow(row)));
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
+			const stmt: InStatement = { sql: query.sql, args: params as InArgs };
+			return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows }) => this.mapAllResult(rows));
 		}
 
 		const rows = await this.values(placeholderValues) as unknown[][];
 
-		if (customResultMapper) {
-			return customResultMapper(rows, normalizeFieldValue) as T['all'];
+		return this.mapAllResult(rows);
+	}
+
+	override mapAllResult(rows: unknown, isFromBatch?: boolean): unknown {
+		if (isFromBatch) {
+			rows = (rows as ResultSet).rows;
+		}
+
+		if (!this.fields && !this.customResultMapper) {
+			return (rows as unknown[]).map((row) => normalizeRow(row));
+		}
+
+		if (this.customResultMapper) {
+			return this.customResultMapper(rows as unknown[][], normalizeFieldValue) as T['all'];
 		}
 
-		return rows.map((row) => {
+		return (rows as unknown[]).map((row) => {
 			return mapResultRow(
-				fields!,
+				this.fields!,
 				Array.prototype.slice.call(row).map((v) => normalizeFieldValue(v)),
-				joinsNotNullableMap,
+				this.joinsNotNullableMap,
 			);
 		});
 	}
 
 	async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-		const { fields, joinsNotNullableMap, logger, queryString, tx, client, customResultMapper } = this;
+		const { fields, logger, query, tx, client, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(this.params, placeholderValues ?? {});
-			logger.logQuery(queryString, params);
-			const stmt: InStatement = { sql: queryString, args: params as InArgs };
-			return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows }) => normalizeRow(rows[0]));
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
+			const stmt: InStatement = { sql: query.sql, args: params as InArgs };
+			return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows }) => this.mapGetResult(rows));
 		}
 
 		const rows = await this.values(placeholderValues) as unknown[][];
 
-		if (!rows[0]) {
+		return this.mapGetResult(rows);
+	}
+
+	override mapGetResult(rows: unknown, isFromBatch?: boolean): unknown {
+		if (isFromBatch) {
+			rows = (rows as ResultSet).rows;
+		}
+
+		const row = (rows as unknown[])[0];
+
+		if (!this.fields && !this.customResultMapper) {
+			return normalizeRow(row);
+		}
+
+		if (!row) {
 			return undefined;
 		}
 
-		if (customResultMapper) {
-			return customResultMapper(rows, normalizeFieldValue) as T['get'];
+		if (this.customResultMapper) {
+			return this.customResultMapper(rows as unknown[][], normalizeFieldValue) as T['get'];
 		}
 
 		return mapResultRow(
-			fields!,
-			Array.prototype.slice.call(rows[0]).map((v) => normalizeFieldValue(v)),
-			joinsNotNullableMap,
+			this.fields!,
+			Array.prototype.slice.call(row).map((v) => normalizeFieldValue(v)),
+			this.joinsNotNullableMap,
 		);
 	}
 
 	values(placeholderValues?: Record<string, unknown>): Promise<T['values']> {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
-		const stmt: InStatement = { sql: this.queryString, args: params as InArgs };
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		const stmt: InStatement = { sql: this.query.sql, args: params as InArgs };
 		return (this.tx ? this.tx.execute(stmt) : this.client.execute(stmt)).then(({ rows }) => rows) as Promise<
 			T['values']
 		>;
@@ -287,7 +255,7 @@ function normalizeRow(obj: any) {
 }
 
 function normalizeFieldValue(value: unknown) {
-	if (value instanceof ArrayBuffer) { // eslint-disable-line no-instanceof/no-instanceof
+	if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { // eslint-disable-line no-instanceof/no-instanceof
 		if (typeof Buffer !== 'undefined') {
 			if (!(value instanceof Buffer)) { // eslint-disable-line no-instanceof/no-instanceof
 				return Buffer.from(value);
diff --git a/drizzle-orm/src/mysql-core/db.ts b/drizzle-orm/src/mysql-core/db.ts
index 3c79f9d86..6e3a1e523 100644
--- a/drizzle-orm/src/mysql-core/db.ts
+++ b/drizzle-orm/src/mysql-core/db.ts
@@ -12,7 +12,7 @@ import { type DrizzleTypeError } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import type { MySqlDialect } from './dialect.ts';
 import {
-	MySqlDelete,
+	MySqlDeleteBase,
 	MySqlInsertBuilder,
 	MySqlSelectBuilder,
 	MySqlUpdateBuilder,
@@ -84,7 +84,7 @@ export class MySqlDatabase<
 		return {
 			as<TSelection extends ColumnsSelection>(
 				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
-			): WithSubqueryWithSelection<TSelection, TAlias, 'mysql'> {
+			): WithSubqueryWithSelection<TSelection, TAlias> {
 				if (typeof qb === 'function') {
 					qb = qb(new QueryBuilder());
 				}
@@ -92,7 +92,7 @@ export class MySqlDatabase<
 				return new Proxy(
 					new WithSubquery(qb.getSQL(), qb.getSelectedFields() as SelectedFields, alias, true),
 					new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-				) as WithSubqueryWithSelection<TSelection, TAlias, 'mysql'>;
+				) as WithSubqueryWithSelection<TSelection, TAlias>;
 			},
 		};
 	}
@@ -159,8 +159,8 @@ export class MySqlDatabase<
 		return new MySqlInsertBuilder(table, this.session, this.dialect);
 	}
 
-	delete<TTable extends MySqlTable>(table: TTable): MySqlDelete<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlDelete(table, this.session, this.dialect);
+	delete<TTable extends MySqlTable>(table: TTable): MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new MySqlDeleteBase(table, this.session, this.dialect);
 	}
 
 	execute<T extends { [column: string]: any } = ResultSetHeader>(
diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index ea6f4ceb9..28b61e123 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -23,7 +23,7 @@ import { DrizzleError } from '../index.ts';
 import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
-import type { Join, MySqlSelectConfig, SelectedFieldsOrdered } from './query-builders/select.types.ts';
+import type { MySqlSelectConfig, MySqlSelectJoinConfig, SelectedFieldsOrdered } from './query-builders/select.types.ts';
 import type { MySqlUpdateConfig } from './query-builders/update.ts';
 import type { MySqlSession } from './session.ts';
 import { MySqlTable } from './table.ts';
@@ -405,7 +405,7 @@ export class MySqlDialect {
 	}): BuildRelationalQueryResult<MySqlTable, MySqlColumn> {
 		let selection: BuildRelationalQueryResult<MySqlTable, MySqlColumn>['selection'] = [];
 		let limit, offset, orderBy: MySqlSelectConfig['orderBy'], where;
-		const joins: Join[] = [];
+		const joins: MySqlSelectJoinConfig[] = [];
 
 		if (config === true) {
 			const selectionEntries = Object.entries(tableConfig.columns);
@@ -578,7 +578,7 @@ export class MySqlDialect {
 		}
 
 		if (selection.length === 0) {
-			throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
+			throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
 		}
 
 		let result;
@@ -869,9 +869,10 @@ export class MySqlDialect {
 		}
 
 		if (selection.length === 0) {
-			throw new DrizzleError(
-				`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`,
-			);
+			throw new DrizzleError({
+				message:
+					`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`,
+			});
 		}
 
 		let result;
diff --git a/drizzle-orm/src/mysql-core/query-builders/delete.ts b/drizzle-orm/src/mysql-core/query-builders/delete.ts
index 31499c079..b8f5a36fd 100644
--- a/drizzle-orm/src/mysql-core/query-builders/delete.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/delete.ts
@@ -1,6 +1,7 @@
 import { entityKind } from '~/entity.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
 import type {
+	AnyQueryResultHKT,
 	MySqlSession,
 	PreparedQueryConfig,
 	PreparedQueryHKTBase,
@@ -13,25 +14,75 @@ import { QueryPromise } from '~/query-promise.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
 import type { SelectedFieldsOrdered } from './select.types.ts';
 
+export type MySqlDeleteWithout<
+	T extends AnyMySqlDeleteBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		MySqlDeleteBase<
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['preparedQueryHKT'],
+			TDynamic,
+			T['_']['excludedMethods'] | K
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type MySqlDelete<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends QueryResultHKT = AnyQueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+> = MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
+
 export interface MySqlDeleteConfig {
 	where?: SQL | undefined;
 	table: MySqlTable;
 	returning?: SelectedFieldsOrdered;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface MySqlDelete<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type MySqlDeletePrepare<T extends AnyMySqlDeleteBase> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: QueryResultKind<T['_']['queryResult'], never>;
+		iterator: never;
+	},
+	true
+>;
+
+type MySqlDeleteDynamic<T extends AnyMySqlDeleteBase> = MySqlDelete<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['preparedQueryHKT']
+>;
+
+type AnyMySqlDeleteBase = MySqlDeleteBase<any, any, any, any, any>;
+
+export interface MySqlDeleteBase<
 	TTable extends MySqlTable,
 	TQueryResult extends QueryResultHKT,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-> extends QueryPromise<QueryResultKind<TQueryResult, never>> {}
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<QueryResultKind<TQueryResult, never>> {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
 
-export class MySqlDelete<
+export class MySqlDeleteBase<
 	TTable extends MySqlTable,
 	TQueryResult extends QueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
 > extends QueryPromise<QueryResultKind<TQueryResult, never>> implements SQLWrapper {
 	static readonly [entityKind]: string = 'MySqlDelete';
 
@@ -46,11 +97,9 @@ export class MySqlDelete<
 		this.config = { table };
 	}
 
-	where(
-		where: SQL | undefined,
-	): Omit<this, 'where'> {
+	where(where: SQL | undefined): MySqlDeleteWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -63,18 +112,11 @@ export class MySqlDelete<
 		return rest;
 	}
 
-	prepare() {
+	prepare(): MySqlDeletePrepare<this> {
 		return this.session.prepareQuery(
 			this.dialect.sqlToQuery(this.getSQL()),
 			this.config.returning,
-		) as PreparedQueryKind<
-			TPreparedQueryHKT,
-			PreparedQueryConfig & {
-				execute: QueryResultKind<TQueryResult, never>;
-				iterator: never;
-			},
-			true
-		>;
+		) as MySqlDeletePrepare<this>;
 	}
 
 	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
@@ -89,4 +131,8 @@ export class MySqlDelete<
 	};
 
 	iterator = this.createIterator();
+
+	$dynamic(): MySqlDeleteDynamic<this> {
+		return this as any;
+	}
 }
diff --git a/drizzle-orm/src/mysql-core/query-builders/insert.ts b/drizzle-orm/src/mysql-core/query-builders/insert.ts
index 299780d22..ddb593aa7 100644
--- a/drizzle-orm/src/mysql-core/query-builders/insert.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/insert.ts
@@ -1,6 +1,7 @@
 import { entityKind, is } from '~/entity.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
 import type {
+	AnyQueryResultHKT,
 	MySqlSession,
 	PreparedQueryConfig,
 	PreparedQueryHKTBase,
@@ -12,7 +13,7 @@ import type { MySqlTable } from '~/mysql-core/table.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { Placeholder, Query, SQLWrapper } from '~/sql/index.ts';
 import { Param, SQL, sql } from '~/sql/index.ts';
-import { type InferModel, Table } from '~/table.ts';
+import { Table } from '~/table.ts';
 import { mapUpdateSet } from '~/utils.ts';
 import type { MySqlUpdateSetSource } from './update.ts';
 
@@ -27,7 +28,7 @@ export type AnyMySqlInsertConfig = MySqlInsertConfig<MySqlTable>;
 
 export type MySqlInsertValue<TTable extends MySqlTable> =
 	& {
-		[Key in keyof InferModel<TTable, 'insert'>]: InferModel<TTable, 'insert'>[Key] | SQL | Placeholder;
+		[Key in keyof TTable['$inferInsert']]: TTable['$inferInsert'][Key] | SQL | Placeholder;
 	}
 	& {};
 
@@ -51,11 +52,11 @@ export class MySqlInsertBuilder<
 		return this;
 	}
 
-	values(value: MySqlInsertValue<TTable>): MySqlInsert<TTable, TQueryResult, TPreparedQueryHKT>;
-	values(values: MySqlInsertValue<TTable>[]): MySqlInsert<TTable, TQueryResult, TPreparedQueryHKT>;
+	values(value: MySqlInsertValue<TTable>): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
+	values(values: MySqlInsertValue<TTable>[]): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
 	values(
 		values: MySqlInsertValue<TTable> | MySqlInsertValue<TTable>[],
-	): MySqlInsert<TTable, TQueryResult, TPreparedQueryHKT> {
+	): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT> {
 		values = Array.isArray(values) ? values : [values];
 		if (values.length === 0) {
 			throw new Error('values() must be called with at least one value');
@@ -70,21 +71,75 @@ export class MySqlInsertBuilder<
 			return result;
 		});
 
-		return new MySqlInsert(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
+		return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
 	}
 }
 
-export interface MySqlInsert<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type MySqlInsertWithout<T extends AnyMySqlInsert, TDynamic extends boolean, K extends keyof T & string> =
+	TDynamic extends true ? T
+		: Omit<
+			MySqlInsertBase<
+				T['_']['table'],
+				T['_']['queryResult'],
+				T['_']['preparedQueryHKT'],
+				TDynamic,
+				T['_']['excludedMethods'] | K
+			>,
+			T['_']['excludedMethods'] | K
+		>;
+
+export type MySqlInsertDynamic<T extends AnyMySqlInsert> = MySqlInsert<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['preparedQueryHKT']
+>;
+
+export type MySqlInsertPrepare<T extends AnyMySqlInsert> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: QueryResultKind<T['_']['queryResult'], never>;
+		iterator: never;
+	},
+	true
+>;
+
+export type MySqlInsertOnDuplicateKeyUpdateConfig<T extends AnyMySqlInsert> = {
+	set: MySqlUpdateSetSource<T['_']['table']>;
+};
+
+export type MySqlInsert<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends QueryResultHKT = AnyQueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+> = MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
+
+export type AnyMySqlInsert = MySqlInsertBase<any, any, any, any, any>;
+
+export interface MySqlInsertBase<
 	TTable extends MySqlTable,
 	TQueryResult extends QueryResultHKT,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-> extends QueryPromise<QueryResultKind<TQueryResult, never>>, SQLWrapper {}
-export class MySqlInsert<
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<QueryResultKind<TQueryResult, never>>, SQLWrapper {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
+
+export class MySqlInsertBase<
 	TTable extends MySqlTable,
 	TQueryResult extends QueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
 > extends QueryPromise<QueryResultKind<TQueryResult, never>> implements SQLWrapper {
 	static readonly [entityKind]: string = 'MySqlInsert';
 
@@ -103,13 +158,12 @@ export class MySqlInsert<
 		this.config = { table, values, ignore };
 	}
 
-	onDuplicateKeyUpdate(config: {
-		// target?: IndexColumn | IndexColumn[];
-		set: MySqlUpdateSetSource<TTable>;
-	}): this {
+	onDuplicateKeyUpdate(
+		config: MySqlInsertOnDuplicateKeyUpdateConfig<this>,
+	): MySqlInsertWithout<this, TDynamic, 'onDuplicateKeyUpdate'> {
 		const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
 		this.config.onConflict = sql`update ${setSql}`;
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -122,18 +176,11 @@ export class MySqlInsert<
 		return rest;
 	}
 
-	prepare() {
+	prepare(): MySqlInsertPrepare<this> {
 		return this.session.prepareQuery(
 			this.dialect.sqlToQuery(this.getSQL()),
 			undefined,
-		) as PreparedQueryKind<
-			TPreparedQueryHKT,
-			PreparedQueryConfig & {
-				execute: QueryResultKind<TQueryResult, never>;
-				iterator: never;
-			},
-			true
-		>;
+		) as MySqlInsertPrepare<this>;
 	}
 
 	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
@@ -148,4 +195,8 @@ export class MySqlInsert<
 	};
 
 	iterator = this.createIterator();
+
+	$dynamic(): MySqlInsertDynamic<this> {
+		return this as any;
+	}
 }
diff --git a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
index b91ce61f5..565105207 100644
--- a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
@@ -18,7 +18,7 @@ export class QueryBuilder {
 		return {
 			as<TSelection extends ColumnsSelection>(
 				qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>),
-			): WithSubqueryWithSelection<TSelection, TAlias, 'mysql'> {
+			): WithSubqueryWithSelection<TSelection, TAlias> {
 				if (typeof qb === 'function') {
 					qb = qb(queryBuilder);
 				}
@@ -26,7 +26,7 @@ export class QueryBuilder {
 				return new Proxy(
 					new WithSubquery(qb.getSQL(), qb.getSelectedFields() as SelectedFields, alias, true),
 					new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-				) as WithSubqueryWithSelection<TSelection, TAlias, 'mysql'>;
+				) as WithSubqueryWithSelection<TSelection, TAlias>;
 			},
 		};
 	}
@@ -35,7 +35,9 @@ export class QueryBuilder {
 		const self = this;
 
 		function select(): MySqlSelectBuilder<undefined, never, 'qb'>;
-		function select<TSelection extends SelectedFields>(fields: TSelection): MySqlSelectBuilder<TSelection, never, 'qb'>;
+		function select<TSelection extends SelectedFields>(
+			fields: TSelection,
+		): MySqlSelectBuilder<TSelection, never, 'qb'>;
 		function select<TSelection extends SelectedFields>(
 			fields?: TSelection,
 		): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
@@ -75,7 +77,9 @@ export class QueryBuilder {
 	}
 
 	selectDistinct(): MySqlSelectBuilder<undefined, never, 'qb'>;
-	selectDistinct<TSelection extends SelectedFields>(fields: TSelection): MySqlSelectBuilder<TSelection, never, 'qb'>;
+	selectDistinct<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): MySqlSelectBuilder<TSelection, never, 'qb'>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields?: TSelection,
 	): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.ts b/drizzle-orm/src/mysql-core/query-builders/select.ts
index c93d97468..bc65edd91 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.ts
@@ -1,12 +1,7 @@
 import { entityKind, is } from '~/entity.ts';
 import type { MySqlColumn } from '~/mysql-core/columns/index.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type {
-	MySqlSession,
-	PreparedQueryConfig,
-	PreparedQueryHKTBase,
-	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
+import type { MySqlSession, PreparedQueryConfig, PreparedQueryHKTBase } from '~/mysql-core/session.ts';
 import type { SubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
 import { MySqlViewBase } from '~/mysql-core/view.ts';
@@ -28,25 +23,19 @@ import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } fro
 import { orderSelectedFields } from '~/utils.ts';
 import { type ColumnsSelection, View, ViewBaseConfig } from '~/view.ts';
 import type {
-	JoinFn,
+	CreateMySqlSelectFromBuilderMode,
 	LockConfig,
 	LockStrength,
+	MySqlJoinFn,
 	MySqlSelectConfig,
+	MySqlSelectDynamic,
 	MySqlSelectHKT,
 	MySqlSelectHKTBase,
-	MySqlSelectQueryBuilderHKT,
+	MySqlSelectPrepare,
+	MySqlSelectWithout,
 	SelectedFields,
 } from './select.types.ts';
 
-type CreateMySqlSelectFromBuilderMode<
-	TBuilderMode extends 'db' | 'qb',
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-> = TBuilderMode extends 'db' ? MySqlSelect<TTableName, TSelection, TSelectMode, TPreparedQueryHKT>
-	: MySqlSelectQueryBuilder<MySqlSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
-
 export class MySqlSelectBuilder<
 	TSelection extends SelectedFields | undefined,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
@@ -107,7 +96,7 @@ export class MySqlSelectBuilder<
 			fields = getTableColumns<MySqlTable>(source);
 		}
 
-		return new MySqlSelect(
+		return new MySqlSelectBase(
 			{
 				table: source,
 				fields,
@@ -121,24 +110,32 @@ export class MySqlSelectBuilder<
 	}
 }
 
-export abstract class MySqlSelectQueryBuilder<
+export abstract class MySqlSelectQueryBuilderBase<
 	THKT extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-> {
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'MySqlSelectQueryBuilder';
 
 	override readonly _: {
-		selectMode: TSelectMode;
-		selection: TSelection;
-		result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-		selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
 	};
 
 	protected config: MySqlSelectConfig;
@@ -171,7 +168,7 @@ export abstract class MySqlSelectQueryBuilder<
 		this.session = session;
 		this.dialect = dialect;
 		this._ = {
-			selectedFields: fields as BuildSubquerySelection<TSelection, TNullabilityMap>,
+			selectedFields: fields as TSelectedFields,
 		} as this['_'];
 		this.tableName = getTableLikeName(table);
 		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
@@ -179,7 +176,7 @@ export abstract class MySqlSelectQueryBuilder<
 
 	private createJoin<TJoinType extends JoinType>(
 		joinType: TJoinType,
-	): JoinFn<THKT, TTableName, TSelectMode, TJoinType, TSelection, TNullabilityMap> {
+	): MySqlJoinFn<this, TDynamic, TJoinType> {
 		return (
 			table: MySqlTable | Subquery | MySqlViewBase | SQL,
 			on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
@@ -250,7 +247,7 @@ export abstract class MySqlSelectQueryBuilder<
 				}
 			}
 
-			return this;
+			return this as any;
 		};
 	}
 
@@ -262,7 +259,9 @@ export abstract class MySqlSelectQueryBuilder<
 
 	fullJoin = this.createJoin('full');
 
-	where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) {
+	where(
+		where: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): MySqlSelectWithout<this, TDynamic, 'where'> {
 		if (typeof where === 'function') {
 			where = where(
 				new Proxy(
@@ -272,10 +271,12 @@ export abstract class MySqlSelectQueryBuilder<
 			);
 		}
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
-	having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) {
+	having(
+		having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): MySqlSelectWithout<this, TDynamic, 'having'> {
 		if (typeof having === 'function') {
 			having = having(
 				new Proxy(
@@ -285,16 +286,18 @@ export abstract class MySqlSelectQueryBuilder<
 			);
 		}
 		this.config.having = having;
-		return this;
+		return this as any;
 	}
 
-	groupBy(builder: (aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): this;
-	groupBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): this;
+	groupBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>,
+	): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
 	groupBy(
 		...columns:
-			| [(aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
+			| [(aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
 			| (MySqlColumn | SQL | SQL.Aliased)[]
-	) {
+	): MySqlSelectWithout<this, TDynamic, 'groupBy'> {
 		if (typeof columns[0] === 'function') {
 			const groupBy = columns[0](
 				new Proxy(
@@ -306,16 +309,18 @@ export abstract class MySqlSelectQueryBuilder<
 		} else {
 			this.config.groupBy = columns as (MySqlColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
-	orderBy(builder: (aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): this;
-	orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): this;
+	orderBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>,
+	): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
 	orderBy(
 		...columns:
-			| [(aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
+			| [(aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
 			| (MySqlColumn | SQL | SQL.Aliased)[]
-	) {
+	): MySqlSelectWithout<this, TDynamic, 'orderBy'> {
 		if (typeof columns[0] === 'function') {
 			const orderBy = columns[0](
 				new Proxy(
@@ -327,22 +332,22 @@ export abstract class MySqlSelectQueryBuilder<
 		} else {
 			this.config.orderBy = columns as (MySqlColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
-	limit(limit: number) {
+	limit(limit: number): MySqlSelectWithout<this, TDynamic, 'limit'> {
 		this.config.limit = limit;
-		return this;
+		return this as any;
 	}
 
-	offset(offset: number) {
+	offset(offset: number): MySqlSelectWithout<this, TDynamic, 'offset'> {
 		this.config.offset = offset;
-		return this;
+		return this as any;
 	}
 
-	for(strength: LockStrength, config: LockConfig = {}) {
+	for(strength: LockStrength, config: LockConfig = {}): MySqlSelectWithout<this, TDynamic, 'for'> {
 		this.config.lockingClause = { strength, config };
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -357,50 +362,79 @@ export abstract class MySqlSelectQueryBuilder<
 
 	as<TAlias extends string>(
 		alias: TAlias,
-	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias, 'mysql'> {
+	): SubqueryWithSelection<this['_']['selectedFields'], TAlias> {
 		return new Proxy(
 			new Subquery(this.getSQL(), this.config.fields, alias),
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias, 'mysql'>;
+		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
+	}
+
+	/** @internal */
+	override getSelectedFields(): this['_']['selectedFields'] {
+		return new Proxy(
+			this.config.fields,
+			new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as this['_']['selectedFields'];
+	}
+
+	$dynamic(): MySqlSelectDynamic<this> {
+		return this as any;
 	}
 }
 
-export interface MySqlSelect<
+export interface MySqlSelectBase<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	MySqlSelectQueryBuilder<
+	MySqlSelectQueryBuilderBase<
 		MySqlSelectHKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
-		TNullabilityMap
+		TPreparedQueryHKT,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
 	>,
-	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	QueryPromise<TResult>
 {}
 
-export class MySqlSelect<
+export class MySqlSelectBase<
 	TTableName extends string | undefined,
 	TSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends MySqlSelectQueryBuilder<
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends MySqlSelectQueryBuilderBase<
 	MySqlSelectHKT,
 	TTableName,
 	TSelection,
 	TSelectMode,
-	TNullabilityMap
+	TPreparedQueryHKT,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
 > {
 	static readonly [entityKind]: string = 'MySqlSelect';
 
-	prepare() {
+	prepare(): MySqlSelectPrepare<this> {
 		if (!this.session) {
 			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
 		}
@@ -410,14 +444,7 @@ export class MySqlSelect<
 			TPreparedQueryHKT
 		>(this.dialect.sqlToQuery(this.getSQL()), fieldsList);
 		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query as PreparedQueryKind<
-			TPreparedQueryHKT,
-			PreparedQueryConfig & {
-				execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-				iterator: SelectResult<TSelection, TSelectMode, TNullabilityMap>;
-			},
-			true
-		>;
+		return query as MySqlSelectPrepare<this>;
 	}
 
 	execute = ((placeholderValues) => {
@@ -434,4 +461,4 @@ export class MySqlSelect<
 	iterator = this.createIterator();
 }
 
-applyMixins(MySqlSelect, [QueryPromise]);
+applyMixins(MySqlSelectBase, [QueryPromise]);
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index b75023cdf..529ce0e5d 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -9,21 +9,23 @@ import type {
 import type {
 	AppendToNullabilityMap,
 	AppendToResult,
+	BuildSubquerySelection,
 	GetSelectTableName,
 	JoinNullability,
 	JoinType,
 	MapColumnsToTableAlias,
 	SelectMode,
+	SelectResult,
 } from '~/query-builders/select.types.ts';
 import type { Placeholder, SQL } from '~/sql/index.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import type { Assume } from '~/utils.ts';
-import { type ColumnsSelection, type View } from '~/view.ts';
-import { type PreparedQueryHKTBase } from '../session.ts';
-import type { MySqlSelect, MySqlSelectQueryBuilder } from './select.ts';
+import type { ColumnsSelection, View } from '~/view.ts';
+import type { PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
+import type { MySqlSelectBase, MySqlSelectQueryBuilderBase } from './select.ts';
 
-export interface Join {
+export interface MySqlSelectJoinConfig {
 	on: SQL | undefined;
 	table: MySqlTable | Subquery | MySqlViewBase | SQL;
 	alias: string | undefined;
@@ -31,8 +33,6 @@ export interface Join {
 	lateral?: boolean;
 }
 
-export type AnyMySqlSelect = MySqlSelect<any, any, any, any>;
-
 export type BuildAliasTable<TTable extends MySqlTable | View, TAlias extends string> = TTable extends Table
 	? MySqlTableWithColumns<
 		UpdateTableConfig<TTable['_']['config'], {
@@ -56,7 +56,7 @@ export interface MySqlSelectConfig {
 	table: MySqlTable | Subquery | MySqlViewBase | SQL;
 	limit?: number | Placeholder;
 	offset?: number | Placeholder;
-	joins?: Join[];
+	joins?: MySqlSelectJoinConfig[];
 	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
 	groupBy?: (MySqlColumn | SQL | SQL.Aliased)[];
 	lockingClause?: {
@@ -66,31 +66,46 @@ export interface MySqlSelectConfig {
 	distinct?: boolean;
 }
 
-export type JoinFn<
-	THKT extends MySqlSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelectMode extends SelectMode,
+export type MySqlJoin<
+	T extends AnyMySqlSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TJoinedTable extends MySqlTable | Subquery | MySqlViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+> = T extends any ? MySqlSelectWithout<
+		MySqlSelectKind<
+			T['_']['hkt'],
+			T['_']['tableName'],
+			AppendToResult<
+				T['_']['tableName'],
+				T['_']['selection'],
+				TJoinedName,
+				TJoinedTable extends MySqlTable ? TJoinedTable['_']['columns']
+					: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: never,
+				T['_']['selectMode']
+			>,
+			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
+			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
+			TDynamic,
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>
+	: never;
+
+export type MySqlJoinFn<
+	T extends AnyMySqlSelectQueryBuilder,
+	TDynamic extends boolean,
 	TJoinType extends JoinType,
-	TSelection,
-	TNullabilityMap extends Record<string, JoinNullability>,
 > = <
 	TJoinedTable extends MySqlTable | Subquery | MySqlViewBase | SQL,
 	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
->(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => MySqlSelectKind<
-	THKT,
-	TTableName,
-	AppendToResult<
-		TTableName,
-		TSelection,
-		TJoinedName,
-		TJoinedTable extends MySqlTable ? TJoinedTable['_']['columns']
-			: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
-			: never,
-		TSelectMode
-	>,
-	TSelectMode extends 'partial' ? TSelectMode : 'multiple',
-	AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>
->;
+>(
+	table: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => MySqlJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
 
 export type SelectedFieldsFlat = SelectedFieldsFlatBase<MySqlColumn>;
 
@@ -117,38 +132,139 @@ export interface MySqlSelectHKTBase {
 	selectMode: SelectMode;
 	preparedQueryHKT: unknown;
 	nullabilityMap: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	selectedFields: unknown;
 	_type: unknown;
 }
 
 export type MySqlSelectKind<
 	T extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
-	TSelection,
+	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability>,
+	TDynamic extends boolean,
+	TExcludedMethods extends string,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > = (T & {
 	tableName: TTableName;
 	selection: TSelection;
 	selectMode: TSelectMode;
 	nullabilityMap: TNullabilityMap;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TResult;
+	selectedFields: TSelectedFields;
 })['_type'];
 
 export interface MySqlSelectQueryBuilderHKT extends MySqlSelectHKTBase {
-	_type: MySqlSelectQueryBuilder<
-		this,
+	_type: MySqlSelectQueryBuilderBase<
+		MySqlSelectQueryBuilderHKT,
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>
+		Assume<this['preparedQueryHKT'], PreparedQueryHKTBase>,
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		this['result'],
+		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
 
 export interface MySqlSelectHKT extends MySqlSelectHKTBase {
-	_type: MySqlSelect<
+	_type: MySqlSelectBase<
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
 		Assume<this['preparedQueryHKT'], PreparedQueryHKTBase>,
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		this['result'],
+		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
+
+export type MySqlSelectWithout<
+	T extends AnyMySqlSelectQueryBuilder,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	MySqlSelectKind<
+		T['_']['hkt'],
+		T['_']['tableName'],
+		T['_']['selection'],
+		T['_']['selectMode'],
+		T['_']['nullabilityMap'],
+		TDynamic,
+		T['_']['excludedMethods'] | K
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type MySqlSelectPrepare<T extends AnyMySqlSelect> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+		iterator: T['_']['result'][number];
+	},
+	true
+>;
+
+export type MySqlSelectDynamic<T extends AnyMySqlSelectQueryBuilder> = MySqlSelectKind<
+	T['_']['hkt'],
+	T['_']['tableName'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
+
+export type CreateMySqlSelectFromBuilderMode<
+	TBuilderMode extends 'db' | 'qb',
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+> = TBuilderMode extends 'db' ? MySqlSelectBase<TTableName, TSelection, TSelectMode, TPreparedQueryHKT>
+	: MySqlSelectQueryBuilderBase<MySqlSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode, TPreparedQueryHKT>;
+
+export type MySqlSelectQueryBuilder<
+	THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT,
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelectMode extends SelectMode = SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TResult = unknown,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = MySqlSelectQueryBuilderBase<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap,
+	true,
+	never,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+
+export type MySqlSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MySqlSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TNullabilityMap, true, never>;
+
+export type AnyMySqlSelect = MySqlSelectBase<any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/mysql-core/query-builders/update.ts b/drizzle-orm/src/mysql-core/query-builders/update.ts
index 3469ede73..5bedea7b9 100644
--- a/drizzle-orm/src/mysql-core/query-builders/update.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/update.ts
@@ -2,6 +2,7 @@ import type { GetColumnData } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
 import type {
+	AnyQueryResultHKT,
 	MySqlSession,
 	PreparedQueryConfig,
 	PreparedQueryHKTBase,
@@ -37,7 +38,9 @@ export class MySqlUpdateBuilder<
 > {
 	static readonly [entityKind]: string = 'MySqlUpdateBuilder';
 
-	declare protected $table: TTable;
+	declare readonly _: {
+		readonly table: TTable;
+	};
 
 	constructor(
 		private table: TTable,
@@ -45,27 +48,77 @@ export class MySqlUpdateBuilder<
 		private dialect: MySqlDialect,
 	) {}
 
-	set(values: MySqlUpdateSetSource<TTable>): MySqlUpdate<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlUpdate(this.table, mapUpdateSet(this.table, values), this.session, this.dialect);
+	set(values: MySqlUpdateSetSource<TTable>): MySqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new MySqlUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect);
 	}
 }
 
-export interface MySqlUpdate<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type MySqlUpdateWithout<
+	T extends AnyMySqlUpdateBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	MySqlUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['preparedQueryHKT'],
+		TDynamic,
+		T['_']['excludedMethods'] | K
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type MySqlUpdatePrepare<T extends AnyMySqlUpdateBase> = PreparedQueryKind<
+	T['_']['preparedQueryHKT'],
+	PreparedQueryConfig & {
+		execute: QueryResultKind<T['_']['queryResult'], never>;
+		iterator: never;
+	},
+	true
+>;
+
+export type MySqlUpdateDynamic<T extends AnyMySqlUpdateBase> = MySqlUpdate<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['preparedQueryHKT']
+>;
+
+export type MySqlUpdate<
+	TTable extends MySqlTable = MySqlTable,
+	TQueryResult extends QueryResultHKT = AnyQueryResultHKT,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+> = MySqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
+
+export type AnyMySqlUpdateBase = MySqlUpdateBase<any, any, any, any, any>;
+
+export interface MySqlUpdateBase<
 	TTable extends MySqlTable,
 	TQueryResult extends QueryResultHKT,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-> extends QueryPromise<QueryResultKind<TQueryResult, never>>, SQLWrapper {}
-export class MySqlUpdate<
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<QueryResultKind<TQueryResult, never>>, SQLWrapper {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
+
+export class MySqlUpdateBase<
 	TTable extends MySqlTable,
 	TQueryResult extends QueryResultHKT,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
 > extends QueryPromise<QueryResultKind<TQueryResult, never>> implements SQLWrapper {
 	static readonly [entityKind]: string = 'MySqlUpdate';
 
-	declare protected $table: TTable;
-
 	private config: MySqlUpdateConfig;
 
 	constructor(
@@ -78,9 +131,9 @@ export class MySqlUpdate<
 		this.config = { set, table };
 	}
 
-	where(where: SQL | undefined): this {
+	where(where: SQL | undefined): MySqlUpdateWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -93,18 +146,11 @@ export class MySqlUpdate<
 		return rest;
 	}
 
-	prepare() {
+	prepare(): MySqlUpdatePrepare<this> {
 		return this.session.prepareQuery(
 			this.dialect.sqlToQuery(this.getSQL()),
 			this.config.returning,
-		) as PreparedQueryKind<
-			TPreparedQueryHKT,
-			PreparedQueryConfig & {
-				execute: QueryResultKind<TQueryResult, never>;
-				iterator: never;
-			},
-			true
-		>;
+		) as MySqlUpdatePrepare<this>;
 	}
 
 	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
@@ -119,4 +165,8 @@ export class MySqlUpdate<
 	};
 
 	iterator = this.createIterator();
+
+	$dynamic(): MySqlUpdateDynamic<this> {
+		return this as any;
+	}
 }
diff --git a/drizzle-orm/src/mysql-core/session.ts b/drizzle-orm/src/mysql-core/session.ts
index 224b7068c..c4346fa54 100644
--- a/drizzle-orm/src/mysql-core/session.ts
+++ b/drizzle-orm/src/mysql-core/session.ts
@@ -15,6 +15,10 @@ export interface QueryResultHKT {
 	readonly type: unknown;
 }
 
+export interface AnyQueryResultHKT extends QueryResultHKT {
+	readonly type: any;
+}
+
 export type QueryResultKind<TKind extends QueryResultHKT, TRow> = (TKind & {
 	readonly row: TRow;
 })['type'];
diff --git a/drizzle-orm/src/mysql-core/subquery.ts b/drizzle-orm/src/mysql-core/subquery.ts
index 603a86b5a..90f7736a6 100644
--- a/drizzle-orm/src/mysql-core/subquery.ts
+++ b/drizzle-orm/src/mysql-core/subquery.ts
@@ -1,4 +1,3 @@
-import { type Dialect } from '~/column-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import type { Subquery, WithSubquery } from '~/subquery.ts';
 import { type ColumnsSelection } from '~/view.ts';
@@ -6,15 +5,13 @@ import { type ColumnsSelection } from '~/view.ts';
 export type SubqueryWithSelection<
 	TSelection extends ColumnsSelection,
 	TAlias extends string,
-	TDialect extends Dialect,
 > =
-	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, TDialect>>
-	& AddAliasToSelection<TSelection, TAlias, TDialect>;
+	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'mysql'>>
+	& AddAliasToSelection<TSelection, TAlias, 'mysql'>;
 
 export type WithSubqueryWithSelection<
 	TSelection extends ColumnsSelection,
 	TAlias extends string,
-	TDialect extends Dialect,
 > =
-	& WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, TDialect>>
-	& AddAliasToSelection<TSelection, TAlias, TDialect>;
+	& WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'mysql'>>
+	& AddAliasToSelection<TSelection, TAlias, 'mysql'>;
diff --git a/drizzle-orm/src/mysql2/driver.ts b/drizzle-orm/src/mysql2/driver.ts
index 87c21df26..cb0561ee2 100644
--- a/drizzle-orm/src/mysql2/driver.ts
+++ b/drizzle-orm/src/mysql2/driver.ts
@@ -66,9 +66,10 @@ export function drizzle<TSchema extends Record<string, unknown> = Record<string,
 	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
 	if (config.schema) {
 		if (config.mode === undefined) {
-			throw new DrizzleError(
-				'You need to specify "mode": "planetscale" or "default" when providing a schema. Read more: https://orm.drizzle.team/docs/rqb#modes',
-			);
+			throw new DrizzleError({
+				message:
+					'You need to specify "mode": "planetscale" or "default" when providing a schema. Read more: https://orm.drizzle.team/docs/rqb#modes',
+			});
 		}
 
 		const tablesConfig = extractTablesRelationalConfig(
diff --git a/drizzle-orm/src/pg-core/db.ts b/drizzle-orm/src/pg-core/db.ts
index 4ac6575ed..ebe919337 100644
--- a/drizzle-orm/src/pg-core/db.ts
+++ b/drizzle-orm/src/pg-core/db.ts
@@ -1,7 +1,7 @@
 import { entityKind } from '~/entity.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
 import {
-	PgDelete,
+	PgDeleteBase,
 	PgInsertBuilder,
 	PgSelectBuilder,
 	PgUpdateBuilder,
@@ -156,8 +156,8 @@ export class PgDatabase<
 		return new PgInsertBuilder(table, this.session, this.dialect);
 	}
 
-	delete<TTable extends PgTable>(table: TTable): PgDelete<TTable, TQueryResult> {
-		return new PgDelete(table, this.session, this.dialect);
+	delete<TTable extends PgTable>(table: TTable): PgDeleteBase<TTable, TQueryResult> {
+		return new PgDeleteBase(table, this.session, this.dialect);
 	}
 
 	refreshMaterializedView<TView extends PgMaterializedView>(view: TView): PgRefreshMaterializedView<TQueryResult> {
diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 5b255b2bd..671ff8e55 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -5,7 +5,11 @@ import { DrizzleError } from '~/errors.ts';
 import type { MigrationMeta } from '~/migrator.ts';
 import { PgColumn, PgDate, PgJson, PgJsonb, PgNumeric, PgTime, PgTimestamp, PgUUID } from '~/pg-core/columns/index.ts';
 import type { PgDeleteConfig, PgInsertConfig, PgUpdateConfig } from '~/pg-core/query-builders/index.ts';
-import type { Join, PgSelectConfig, SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
+import type {
+	PgSelectConfig,
+	PgSelectJoinConfig,
+	SelectedFieldsOrdered,
+} from '~/pg-core/query-builders/select.types.ts';
 import { PgTable } from '~/pg-core/table.ts';
 import {
 	type BuildRelationalQueryResult,
@@ -199,7 +203,7 @@ export class PgDialect {
 			groupBy,
 			limit,
 			offset,
-			lockingClauses,
+			lockingClause,
 			distinct,
 		}: PgSelectConfig,
 	): SQL {
@@ -324,23 +328,21 @@ export class PgDialect {
 
 		const offsetSql = offset ? sql` offset ${offset}` : undefined;
 
-		const lockingClausesSql = sql.empty();
-		if (lockingClauses) {
-			for (const { strength, config } of lockingClauses) {
-				const clauseSql = sql` for ${sql.raw(strength)}`;
-				if (config.of) {
-					clauseSql.append(sql` of ${config.of}`);
-				}
-				if (config.noWait) {
-					clauseSql.append(sql` no wait`);
-				} else if (config.skipLocked) {
-					clauseSql.append(sql` skip locked`);
-				}
-				lockingClausesSql.append(clauseSql);
+		const lockingClauseSql = sql.empty();
+		if (lockingClause) {
+			const clauseSql = sql` for ${sql.raw(lockingClause.strength)}`;
+			if (lockingClause.config.of) {
+				clauseSql.append(sql` of ${lockingClause.config.of}`);
+			}
+			if (lockingClause.config.noWait) {
+				clauseSql.append(sql` no wait`);
+			} else if (lockingClause.config.skipLocked) {
+				clauseSql.append(sql` skip locked`);
 			}
+			lockingClauseSql.append(clauseSql);
 		}
 
-		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
+		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
 	}
 
 	buildInsertQuery({ table, values, onConflict, returning }: PgInsertConfig): SQL {
@@ -977,7 +979,7 @@ export class PgDialect {
 	}): BuildRelationalQueryResult<PgTable, PgColumn> {
 		let selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = [];
 		let limit, offset, orderBy: NonNullable<PgSelectConfig['orderBy']> = [], where;
-		const joins: Join[] = [];
+		const joins: PgSelectJoinConfig[] = [];
 
 		if (config === true) {
 			const selectionEntries = Object.entries(tableConfig.columns);
@@ -1150,7 +1152,7 @@ export class PgDialect {
 		}
 
 		if (selection.length === 0) {
-			throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
+			throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
 		}
 
 		let result;
diff --git a/drizzle-orm/src/pg-core/query-builders/delete.ts b/drizzle-orm/src/pg-core/query-builders/delete.ts
index c62795ad9..28dfaba09 100644
--- a/drizzle-orm/src/pg-core/query-builders/delete.ts
+++ b/drizzle-orm/src/pg-core/query-builders/delete.ts
@@ -11,29 +11,108 @@ import type { PgTable } from '~/pg-core/table.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
-import { type InferModel, Table } from '~/table.ts';
+import { Table } from '~/table.ts';
 import { tracer } from '~/tracing.ts';
 import { orderSelectedFields } from '~/utils.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
 
+export type PgDeleteWithout<
+	T extends AnyPgDeleteBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		PgDeleteBase<
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['returning'],
+			TDynamic,
+			T['_']['excludedMethods'] | K
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type PgDelete<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends QueryResultHKT = QueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = PgDeleteBase<TTable, TQueryResult, TReturning, true, never>;
+
 export interface PgDeleteConfig {
 	where?: SQL | undefined;
 	table: PgTable;
 	returning?: SelectedFieldsOrdered;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface PgDelete<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type PgDeleteReturningAll<
+	T extends AnyPgDeleteBase,
+	TDynamic extends boolean,
+> = PgDeleteWithout<
+	PgDeleteBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['table']['$inferSelect'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type PgDeleteReturning<
+	T extends AnyPgDeleteBase,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFieldsFlat,
+> = PgDeleteWithout<
+	PgDeleteBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		SelectResultFields<TSelectedFields>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type PgDeletePrepare<T extends AnyPgDeleteBase> = PreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? QueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type PgDeleteDynamic<T extends AnyPgDeleteBase> = PgDelete<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['returning']
+>;
+
+export type AnyPgDeleteBase = PgDeleteBase<any, any, any, any, any>;
+
+export interface PgDeleteBase<
 	TTable extends PgTable,
 	TQueryResult extends QueryResultHKT,
 	TReturning extends Record<string, unknown> | undefined = undefined,
-> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> {}
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]> {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
 
-export class PgDelete<
+export class PgDeleteBase<
 	TTable extends PgTable,
 	TQueryResult extends QueryResultHKT,
 	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
 > extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>
 	implements SQLWrapper
 {
@@ -50,18 +129,20 @@ export class PgDelete<
 		this.config = { table };
 	}
 
-	where(where: SQL | undefined): Omit<this, 'where'> {
+	where(where: SQL | undefined): PgDeleteWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
-	returning(): PgDelete<TTable, TQueryResult, InferModel<TTable>>;
+	returning(): PgDeleteReturningAll<this, TDynamic>;
 	returning<TSelectedFields extends SelectedFieldsFlat>(
 		fields: TSelectedFields,
-	): PgDelete<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
-	returning(fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns]): PgDelete<TTable, any, any> {
+	): PgDeleteReturning<this, TDynamic, TSelectedFields>;
+	returning(
+		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
+	): PgDeleteReturning<this, TDynamic, any> {
 		this.config.returning = orderSelectedFields(fields);
-		return this as PgDelete<TTable, any>;
+		return this as any;
 	}
 
 	/** @internal */
@@ -74,11 +155,7 @@ export class PgDelete<
 		return rest;
 	}
 
-	private _prepare(name?: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-		}
-	> {
+	private _prepare(name?: string): PgDeletePrepare<this> {
 		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
 			return this.session.prepareQuery<
 				PreparedQueryConfig & {
@@ -88,11 +165,7 @@ export class PgDelete<
 		});
 	}
 
-	prepare(name: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-		}
-	> {
+	prepare(name: string): PgDeletePrepare<this> {
 		return this._prepare(name);
 	}
 
@@ -101,4 +174,8 @@ export class PgDelete<
 			return this._prepare().execute(placeholderValues);
 		});
 	};
+
+	$dynamic(): PgDeleteDynamic<this> {
+		return this as any;
+	}
 }
diff --git a/drizzle-orm/src/pg-core/query-builders/insert.ts b/drizzle-orm/src/pg-core/query-builders/insert.ts
index f2c1f089e..93bf3aa43 100644
--- a/drizzle-orm/src/pg-core/query-builders/insert.ts
+++ b/drizzle-orm/src/pg-core/query-builders/insert.ts
@@ -13,7 +13,7 @@ import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { Placeholder, Query, SQLWrapper } from '~/sql/index.ts';
 import { Param, SQL, sql } from '~/sql/index.ts';
-import { type InferModel, Table } from '~/table.ts';
+import { Table } from '~/table.ts';
 import { tracer } from '~/tracing.ts';
 import { mapUpdateSet, orderSelectedFields } from '~/utils.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
@@ -28,7 +28,7 @@ export interface PgInsertConfig<TTable extends PgTable = PgTable> {
 
 export type PgInsertValue<TTable extends PgTable> =
 	& {
-		[Key in keyof InferModel<TTable, 'insert'>]: InferModel<TTable, 'insert'>[Key] | SQL | Placeholder;
+		[Key in keyof TTable['$inferInsert']]: TTable['$inferInsert'][Key] | SQL | Placeholder;
 	}
 	& {};
 
@@ -41,9 +41,9 @@ export class PgInsertBuilder<TTable extends PgTable, TQueryResult extends QueryR
 		private dialect: PgDialect,
 	) {}
 
-	values(value: PgInsertValue<TTable>): PgInsert<TTable, TQueryResult>;
-	values(values: PgInsertValue<TTable>[]): PgInsert<TTable, TQueryResult>;
-	values(values: PgInsertValue<TTable> | PgInsertValue<TTable>[]): PgInsert<TTable, TQueryResult> {
+	values(value: PgInsertValue<TTable>): PgInsertBase<TTable, TQueryResult>;
+	values(values: PgInsertValue<TTable>[]): PgInsertBase<TTable, TQueryResult>;
+	values(values: PgInsertValue<TTable> | PgInsertValue<TTable>[]): PgInsertBase<TTable, TQueryResult> {
 		values = Array.isArray(values) ? values : [values];
 		if (values.length === 0) {
 			throw new Error('values() must be called with at least one value');
@@ -58,34 +58,99 @@ export class PgInsertBuilder<TTable extends PgTable, TQueryResult extends QueryR
 			return result;
 		});
 
-		return new PgInsert(this.table, mappedValues, this.session, this.dialect);
+		return new PgInsertBase(this.table, mappedValues, this.session, this.dialect);
 	}
 }
 
-export interface PgInsert<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type PgInsertWithout<T extends AnyPgInsert, TDynamic extends boolean, K extends keyof T & string> =
+	TDynamic extends true ? T
+		: Omit<
+			PgInsertBase<
+				T['_']['table'],
+				T['_']['queryResult'],
+				T['_']['returning'],
+				TDynamic,
+				T['_']['excludedMethods'] | K
+			>,
+			T['_']['excludedMethods'] | K
+		>;
+
+export type PgInsertReturning<
+	T extends AnyPgInsert,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFieldsFlat,
+> = PgInsertBase<
+	T['_']['table'],
+	T['_']['queryResult'],
+	SelectResultFields<TSelectedFields>,
+	TDynamic,
+	T['_']['excludedMethods']
+>;
+
+export type PgInsertReturningAll<T extends AnyPgInsert, TDynamic extends boolean> = PgInsertBase<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['table']['$inferSelect'],
+	TDynamic,
+	T['_']['excludedMethods']
+>;
+
+export interface PgInsertOnConflictDoUpdateConfig<T extends AnyPgInsert> {
+	target: IndexColumn | IndexColumn[];
+	where?: SQL;
+	set: PgUpdateSetSource<T['_']['table']>;
+}
+
+export type PgInsertPrepare<T extends AnyPgInsert> = PreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? QueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type PgInsertDynamic<T extends AnyPgInsert> = PgInsert<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['returning']
+>;
+
+export type AnyPgInsert = PgInsertBase<any, any, any, any, any>;
+
+export interface PgInsertBase<
 	TTable extends PgTable,
 	TQueryResult extends QueryResultHKT,
 	TReturning extends Record<string, unknown> | undefined = undefined,
-> extends
-	QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>,
-	SQLWrapper
-{}
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
 
-export class PgInsert<
+export type PgInsert<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends QueryResultHKT = QueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = PgInsertBase<TTable, TQueryResult, TReturning, true, never>;
+
+export class PgInsertBase<
 	TTable extends PgTable,
 	TQueryResult extends QueryResultHKT,
 	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
 > extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>
 	implements SQLWrapper
 {
 	static readonly [entityKind]: string = 'PgInsert';
 
-	declare _: {
-		table: TTable;
-		return: TReturning;
-	};
-
 	private config: PgInsertConfig<TTable>;
 
 	constructor(
@@ -98,18 +163,20 @@ export class PgInsert<
 		this.config = { table, values };
 	}
 
-	returning(): PgInsert<TTable, TQueryResult, InferModel<TTable>>;
+	returning(): PgInsertWithout<PgInsertReturningAll<this, TDynamic>, TDynamic, 'returning'>;
 	returning<TSelectedFields extends SelectedFieldsFlat>(
 		fields: TSelectedFields,
-	): PgInsert<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
+	): PgInsertWithout<PgInsertReturning<this, TDynamic, TSelectedFields>, TDynamic, 'returning'>;
 	returning(
 		fields: SelectedFieldsFlat = this.config.table[Table.Symbol.Columns],
-	): PgInsert<TTable, any, any> {
+	): PgInsertWithout<AnyPgInsert, TDynamic, 'returning'> {
 		this.config.returning = orderSelectedFields(fields);
-		return this;
+		return this as any;
 	}
 
-	onConflictDoNothing(config: { target?: IndexColumn | IndexColumn[]; where?: SQL } = {}): this {
+	onConflictDoNothing(
+		config: { target?: IndexColumn | IndexColumn[]; where?: SQL } = {},
+	): PgInsertWithout<this, TDynamic, 'onConflictDoNothing' | 'onConflictDoUpdate'> {
 		if (config.target === undefined) {
 			this.config.onConflict = sql`do nothing`;
 		} else {
@@ -121,14 +188,12 @@ export class PgInsert<
 			const whereSql = config.where ? sql` where ${config.where}` : undefined;
 			this.config.onConflict = sql`(${sql.raw(targetColumn)}) do nothing${whereSql}`;
 		}
-		return this;
+		return this as any;
 	}
 
-	onConflictDoUpdate(config: {
-		target: IndexColumn | IndexColumn[];
-		where?: SQL;
-		set: PgUpdateSetSource<TTable>;
-	}): this {
+	onConflictDoUpdate(
+		config: PgInsertOnConflictDoUpdateConfig<this>,
+	): PgInsertWithout<this, TDynamic, 'onConflictDoNothing' | 'onConflictDoUpdate'> {
 		const whereSql = config.where ? sql` where ${config.where}` : undefined;
 		const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
 		let targetColumn = '';
@@ -136,7 +201,7 @@ export class PgInsert<
 			? config.target.map((it) => this.dialect.escapeName(it.name)).join(',')
 			: this.dialect.escapeName(config.target.name);
 		this.config.onConflict = sql`(${sql.raw(targetColumn)}) do update set ${setSql}${whereSql}`;
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -149,11 +214,7 @@ export class PgInsert<
 		return rest;
 	}
 
-	private _prepare(name?: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-		}
-	> {
+	private _prepare(name?: string): PgInsertPrepare<this> {
 		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
 			return this.session.prepareQuery<
 				PreparedQueryConfig & {
@@ -163,11 +224,7 @@ export class PgInsert<
 		});
 	}
 
-	prepare(name: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-		}
-	> {
+	prepare(name: string): PgInsertPrepare<this> {
 		return this._prepare(name);
 	}
 
@@ -176,4 +233,8 @@ export class PgInsert<
 			return this._prepare().execute(placeholderValues);
 		});
 	};
+
+	$dynamic(): PgInsertDynamic<this> {
+		return this as any;
+	}
 }
diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index 7179a43eb..a18664906 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -1,7 +1,7 @@
 import { entityKind, is } from '~/entity.ts';
 import type { PgColumn } from '~/pg-core/columns/index.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
-import type { PgSession, PreparedQuery, PreparedQueryConfig } from '~/pg-core/session.ts';
+import type { PgSession, PreparedQueryConfig } from '~/pg-core/session.ts';
 import type { SubqueryWithSelection } from '~/pg-core/subquery.ts';
 import type { PgTable } from '~/pg-core/table.ts';
 import { PgViewBase } from '~/pg-core/view.ts';
@@ -24,24 +24,19 @@ import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } fro
 import { orderSelectedFields } from '~/utils.ts';
 import { type ColumnsSelection, View, ViewBaseConfig } from '~/view.ts';
 import type {
-	JoinFn,
+	CreatePgSelectFromBuilderMode,
 	LockConfig,
 	LockStrength,
+	PgJoinFn,
 	PgSelectConfig,
+	PgSelectDynamic,
 	PgSelectHKT,
 	PgSelectHKTBase,
-	PgSelectQueryBuilderHKT,
+	PgSelectPrepare,
+	PgSelectWithout,
 	SelectedFields,
 } from './select.types.ts';
 
-type CreatePgSelectFromBuilderMode<
-	TBuilderMode extends 'db' | 'qb',
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-> = TBuilderMode extends 'db' ? PgSelect<TTableName, TSelection, TSelectMode>
-	: PgSelectQueryBuilder<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
-
 export class PgSelectBuilder<
 	TSelection extends SelectedFields | undefined,
 	TBuilderMode extends 'db' | 'qb' = 'db',
@@ -80,7 +75,7 @@ export class PgSelectBuilder<
 	 * Specify the table, subquery, or other target that you're
 	 * building a select query against.
 	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM|Postgres from documentation}
+	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM | Postgres from documentation}
 	 */
 	from<TFrom extends PgTable | Subquery | PgViewBase | SQL>(
 		source: TFrom,
@@ -110,7 +105,7 @@ export class PgSelectBuilder<
 			fields = getTableColumns<PgTable>(source);
 		}
 
-		return new PgSelect({
+		return new PgSelectBase({
 			table: source,
 			fields,
 			isPartialSelect,
@@ -122,24 +117,30 @@ export class PgSelectBuilder<
 	}
 }
 
-export abstract class PgSelectQueryBuilder<
+export abstract class PgSelectQueryBuilderBase<
 	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-> {
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'PgSelectQueryBuilder';
 
 	override readonly _: {
-		readonly selectMode: TSelectMode;
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
 		readonly selection: TSelection;
-		readonly result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-		readonly selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
 	};
 
 	protected config: PgSelectConfig;
@@ -173,7 +174,7 @@ export abstract class PgSelectQueryBuilder<
 		this.session = session;
 		this.dialect = dialect;
 		this._ = {
-			selectedFields: fields as BuildSubquerySelection<TSelection, TNullabilityMap>,
+			selectedFields: fields as TSelectedFields,
 		} as this['_'];
 		this.tableName = getTableLikeName(table);
 		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
@@ -181,7 +182,7 @@ export abstract class PgSelectQueryBuilder<
 
 	private createJoin<TJoinType extends JoinType>(
 		joinType: TJoinType,
-	): JoinFn<THKT, TTableName, TSelectMode, TJoinType, TSelection, TNullabilityMap> {
+	): PgJoinFn<this, TDynamic, TJoinType> {
 		return (
 			table: PgTable | Subquery | PgViewBase | SQL,
 			on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
@@ -252,7 +253,7 @@ export abstract class PgSelectQueryBuilder<
 				}
 			}
 
-			return this;
+			return this as any;
 		};
 	}
 
@@ -301,7 +302,9 @@ export abstract class PgSelectQueryBuilder<
 	 * db.select().from(cars).where(eq(cars.year, 2000));
 	 * ```
 	 */
-	where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) {
+	where(
+		where: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): PgSelectWithout<this, TDynamic, 'where'> {
 		if (typeof where === 'function') {
 			where = where(
 				new Proxy(
@@ -311,7 +314,7 @@ export abstract class PgSelectQueryBuilder<
 			);
 		}
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
 	/**
@@ -319,9 +322,11 @@ export abstract class PgSelectQueryBuilder<
 	 * used with GROUP BY and filters rows after they've been
 	 * grouped together and combined.
 	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-HAVING|Postgres having clause documentation}
+	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-HAVING | Postgres having clause documentation}
 	 */
-	having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) {
+	having(
+		having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): PgSelectWithout<this, TDynamic, 'having'> {
 		if (typeof having === 'function') {
 			having = having(
 				new Proxy(
@@ -331,7 +336,7 @@ export abstract class PgSelectQueryBuilder<
 			);
 		}
 		this.config.having = having;
-		return this;
+		return this as any;
 	}
 
 	/**
@@ -350,15 +355,17 @@ export abstract class PgSelectQueryBuilder<
 	 * }).from(people).groupBy(people.lastName);
 	 * ```
 	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-GROUPBY|Postgres GROUP BY documentation}
+	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-GROUPBY | Postgres GROUP BY documentation}
 	 */
-	groupBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
-	groupBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+	groupBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<PgColumn | SQL | SQL.Aliased>,
+	): PgSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): PgSelectWithout<this, TDynamic, 'groupBy'>;
 	groupBy(
 		...columns:
-			| [(aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>]
+			| [(aliases: this['_']['selection']) => ValueOrArray<PgColumn | SQL | SQL.Aliased>]
 			| (PgColumn | SQL | SQL.Aliased)[]
-	) {
+	): PgSelectWithout<this, TDynamic, 'groupBy'> {
 		if (typeof columns[0] === 'function') {
 			const groupBy = columns[0](
 				new Proxy(
@@ -370,7 +377,7 @@ export abstract class PgSelectQueryBuilder<
 		} else {
 			this.config.groupBy = columns as (PgColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
 	/**
@@ -386,15 +393,17 @@ export abstract class PgSelectQueryBuilder<
 	 * db.select().from(cars).orderBy(cars.year);
 	 * ```
 	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-ORDERBY|Postgres ORDER BY documentation}
+	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-ORDERBY | Postgres ORDER BY documentation}
 	 */
-	orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
-	orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+	orderBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<PgColumn | SQL | SQL.Aliased>,
+	): PgSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): PgSelectWithout<this, TDynamic, 'orderBy'>;
 	orderBy(
 		...columns:
-			| [(aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>]
+			| [(aliases: this['_']['selection']) => ValueOrArray<PgColumn | SQL | SQL.Aliased>]
 			| (PgColumn | SQL | SQL.Aliased)[]
-	) {
+	): PgSelectWithout<this, TDynamic, 'orderBy'> {
 		if (typeof columns[0] === 'function') {
 			const orderBy = columns[0](
 				new Proxy(
@@ -406,7 +415,7 @@ export abstract class PgSelectQueryBuilder<
 		} else {
 			this.config.orderBy = columns as (PgColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
 	/**
@@ -420,11 +429,11 @@ export abstract class PgSelectQueryBuilder<
 	 * db.select().from(people).limit(10);
 	 * ```
 	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT|Postgres LIMIT documentation}
+	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT | Postgres LIMIT documentation}
 	 */
-	limit(limit: number | Placeholder) {
+	limit(limit: number | Placeholder): PgSelectWithout<this, TDynamic, 'limit'> {
 		this.config.limit = limit;
-		return this;
+		return this as any;
 	}
 
 	/**
@@ -438,9 +447,9 @@ export abstract class PgSelectQueryBuilder<
 	 * db.select().from(people).offset(10).limit(10);
 	 * ```
 	 */
-	offset(offset: number | Placeholder) {
+	offset(offset: number | Placeholder): PgSelectWithout<this, TDynamic, 'offset'> {
 		this.config.offset = offset;
-		return this;
+		return this as any;
 	}
 
 	/**
@@ -448,14 +457,11 @@ export abstract class PgSelectQueryBuilder<
 	 * that controls how strictly it acquires exclusive access to
 	 * the rows being queried.
 	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE|Postgres locking clause documentation}
+	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE | PostgreSQL locking clause documentation}
 	 */
-	for(strength: LockStrength, config: LockConfig = {}) {
-		if (!this.config.lockingClauses) {
-			this.config.lockingClauses = [];
-		}
-		this.config.lockingClauses.push({ strength, config });
-		return this;
+	for(strength: LockStrength, config: LockConfig = {}): PgSelectWithout<this, TDynamic, 'for'> {
+		this.config.lockingClause = { strength, config };
+		return this as any;
 	}
 
 	/** @internal */
@@ -470,39 +476,75 @@ export abstract class PgSelectQueryBuilder<
 
 	as<TAlias extends string>(
 		alias: TAlias,
-	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias> {
+	): SubqueryWithSelection<this['_']['selectedFields'], TAlias> {
 		return new Proxy(
 			new Subquery(this.getSQL(), this.config.fields, alias),
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
+	}
+
+	/** @internal */
+	override getSelectedFields(): this['_']['selectedFields'] {
+		return new Proxy(
+			this.config.fields,
+			new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
+		) as this['_']['selectedFields'];
+	}
+
+	$dynamic(): PgSelectDynamic<this> {
+		return this;
 	}
 }
 
-export interface PgSelect<
+export interface PgSelectBase<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	PgSelectQueryBuilderBase<
+		PgSelectHKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	QueryPromise<TResult>
 {}
 
-export class PgSelect<
+export class PgSelectBase<
 	TTableName extends string | undefined,
-	TSelection,
+	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends PgSelectQueryBuilder<PgSelectHKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends PgSelectQueryBuilderBase<
+	PgSelectHKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> {
 	static readonly [entityKind]: string = 'PgSelect';
 
-	private _prepare(name?: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-		}
-	> {
+	private _prepare(name?: string): PgSelectPrepare<this> {
 		const { session, config, dialect, joinsNotNullableMap } = this;
 		if (!session) {
 			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
@@ -510,7 +552,7 @@ export class PgSelect<
 		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
 			const fieldsList = orderSelectedFields<PgColumn>(config.fields);
 			const query = session.prepareQuery<
-				PreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] }
+				PreparedQueryConfig & { execute: TResult }
 			>(dialect.sqlToQuery(this.getSQL()), fieldsList, name);
 			query.joinsNotNullableMap = joinsNotNullableMap;
 			return query;
@@ -522,13 +564,9 @@ export class PgSelect<
 	 * the database to remember this query for the given session
 	 * and call it by name, rather than specifying the full query.
 	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html|Postgres prepare documentation}
+	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
 	 */
-	prepare(name: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-		}
-	> {
+	prepare(name: string): PgSelectPrepare<this> {
 		return this._prepare(name);
 	}
 
@@ -539,4 +577,4 @@ export class PgSelect<
 	};
 }
 
-applyMixins(PgSelect, [QueryPromise]);
+applyMixins(PgSelectBase, [QueryPromise]);
diff --git a/drizzle-orm/src/pg-core/query-builders/select.types.ts b/drizzle-orm/src/pg-core/query-builders/select.types.ts
index 2ab6d4e62..949736a3a 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.types.ts
@@ -9,20 +9,23 @@ import type { PgViewBase, PgViewWithSelection } from '~/pg-core/view.ts';
 import type {
 	AppendToNullabilityMap,
 	AppendToResult,
+	BuildSubquerySelection,
 	GetSelectTableName,
 	JoinNullability,
 	JoinType,
 	MapColumnsToTableAlias,
 	SelectMode,
+	SelectResult,
 } from '~/query-builders/select.types.ts';
 import type { Placeholder, SQL, SQLWrapper } from '~/sql/index.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
-import type { Assume } from '~/utils.ts';
-import { type ColumnsSelection, type View } from '~/view.ts';
-import type { PgSelect, PgSelectQueryBuilder } from './select.ts';
+import type { Assume, ValueOrArray } from '~/utils.ts';
+import type { ColumnsSelection, View } from '~/view.ts';
+import type { PreparedQuery, PreparedQueryConfig } from '../session.ts';
+import type { PgSelectBase, PgSelectQueryBuilderBase } from './select.ts';
 
-export interface Join {
+export interface PgSelectJoinConfig {
 	on: SQL | undefined;
 	table: PgTable | Subquery | PgViewBase | SQL;
 	alias: string | undefined;
@@ -30,8 +33,6 @@ export interface Join {
 	lateral?: boolean;
 }
 
-export type AnyPgSelect = PgSelect<any, any, any, any>;
-
 export type BuildAliasTable<TTable extends PgTable | View, TAlias extends string> = TTable extends Table
 	? PgTableWithColumns<
 		UpdateTableConfig<TTable['_']['config'], {
@@ -56,43 +57,58 @@ export interface PgSelectConfig {
 	table: PgTable | Subquery | PgViewBase | SQL;
 	limit?: number | Placeholder;
 	offset?: number | Placeholder;
-	joins?: Join[];
+	joins?: PgSelectJoinConfig[];
 	orderBy?: (PgColumn | SQL | SQL.Aliased)[];
 	groupBy?: (PgColumn | SQL | SQL.Aliased)[];
-	lockingClauses?: {
+	lockingClause?: {
 		strength: LockStrength;
 		config: LockConfig;
-	}[];
+	};
 	distinct?: boolean | {
 		on: (PgColumn | SQLWrapper)[];
 	};
 }
 
-export type JoinFn<
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelectMode extends SelectMode,
+export type PgJoin<
+	T extends AnyPgSelectQueryBuilderBase,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TJoinedTable extends PgTable | Subquery | PgViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+> = T extends any ? PgSelectWithout<
+		PgSelectKind<
+			T['_']['hkt'],
+			T['_']['tableName'],
+			AppendToResult<
+				T['_']['tableName'],
+				T['_']['selection'],
+				TJoinedName,
+				TJoinedTable extends Table ? TJoinedTable['_']['columns']
+					: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: never,
+				T['_']['selectMode']
+			>,
+			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
+			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
+			T['_']['dynamic'],
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>
+	: never;
+
+export type PgJoinFn<
+	T extends AnyPgSelectQueryBuilderBase,
+	TDynamic extends boolean,
 	TJoinType extends JoinType,
-	TSelection,
-	TNullabilityMap extends Record<string, JoinNullability>,
 > = <
 	TJoinedTable extends PgTable | Subquery | PgViewBase | SQL,
 	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
->(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => PgSelectKind<
-	THKT,
-	TTableName,
-	AppendToResult<
-		TTableName,
-		TSelection,
-		TJoinedName,
-		TJoinedTable extends Table ? TJoinedTable['_']['columns']
-			: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
-			: never,
-		TSelectMode
-	>,
-	TSelectMode extends 'partial' ? TSelectMode : 'multiple',
-	AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>
->;
+>(
+	table: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => PgJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
 
 export type SelectedFieldsFlat = SelectedFieldsFlatBase<PgColumn>;
 
@@ -104,7 +120,7 @@ export type LockStrength = 'update' | 'no key update' | 'share' | 'key share';
 
 export type LockConfig =
 	& {
-		of?: PgTable;
+		of?: ValueOrArray<PgTable>;
 	}
 	& ({
 		noWait: true;
@@ -122,37 +138,133 @@ export interface PgSelectHKTBase {
 	selection: unknown;
 	selectMode: SelectMode;
 	nullabilityMap: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	selectedFields: unknown;
 	_type: unknown;
 }
 
 export type PgSelectKind<
 	T extends PgSelectHKTBase,
 	TTableName extends string | undefined,
-	TSelection,
+	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability>,
+	TDynamic extends boolean,
+	TExcludedMethods extends string,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > = (T & {
 	tableName: TTableName;
 	selection: TSelection;
 	selectMode: TSelectMode;
 	nullabilityMap: TNullabilityMap;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TResult;
+	selectedFields: TSelectedFields;
 })['_type'];
 
 export interface PgSelectQueryBuilderHKT extends PgSelectHKTBase {
-	_type: PgSelectQueryBuilder<
-		this,
+	_type: PgSelectQueryBuilderBase<
+		PgSelectQueryBuilderHKT,
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		this['result'],
+		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
 
 export interface PgSelectHKT extends PgSelectHKTBase {
-	_type: PgSelect<
+	_type: PgSelectBase<
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		this['result'],
+		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
+
+export type CreatePgSelectFromBuilderMode<
+	TBuilderMode extends 'db' | 'qb',
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+> = TBuilderMode extends 'db' ? PgSelectBase<TTableName, TSelection, TSelectMode>
+	: PgSelectQueryBuilderBase<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
+
+export type PgSelectWithout<
+	T extends AnyPgSelectQueryBuilderBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	PgSelectKind<
+		T['_']['hkt'],
+		T['_']['tableName'],
+		T['_']['selection'],
+		T['_']['selectMode'],
+		T['_']['nullabilityMap'],
+		TDynamic,
+		T['_']['excludedMethods'] | K,
+		T['_']['result'],
+		T['_']['selectedFields']
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type PgSelectPrepare<T extends AnyPgSelect> = PreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['result'];
+	}
+>;
+
+export type PgSelectDynamic<T extends AnyPgSelectQueryBuilderBase> = PgSelectKind<
+	T['_']['hkt'],
+	T['_']['tableName'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
+
+export type PgSelectQueryBuilder<
+	THKT extends PgSelectHKTBase = PgSelectQueryBuilderHKT,
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TResult = unknown,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = PgSelectQueryBuilderBase<
+	THKT,
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnyPgSelectQueryBuilderBase = PgSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+
+export type PgSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnyPgSelect = PgSelectBase<any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/pg-core/query-builders/update.ts b/drizzle-orm/src/pg-core/query-builders/update.ts
index 4139e484b..6b7b24d92 100644
--- a/drizzle-orm/src/pg-core/query-builders/update.ts
+++ b/drizzle-orm/src/pg-core/query-builders/update.ts
@@ -12,7 +12,7 @@ import type { PgTable } from '~/pg-core/table.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
-import { type InferModel, Table } from '~/table.ts';
+import { Table } from '~/table.ts';
 import { mapUpdateSet, orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import type { SelectedFields, SelectedFieldsOrdered } from './select.types.ts';
 
@@ -44,35 +44,109 @@ export class PgUpdateBuilder<TTable extends PgTable, TQueryResult extends QueryR
 		private dialect: PgDialect,
 	) {}
 
-	set(values: PgUpdateSetSource<TTable>): PgUpdate<TTable, TQueryResult> {
-		return new PgUpdate<TTable, TQueryResult>(this.table, mapUpdateSet(this.table, values), this.session, this.dialect);
+	set(values: PgUpdateSetSource<TTable>): PgUpdateBase<TTable, TQueryResult> {
+		return new PgUpdateBase<TTable, TQueryResult>(
+			this.table,
+			mapUpdateSet(this.table, values),
+			this.session,
+			this.dialect,
+		);
 	}
 }
 
-export interface PgUpdate<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type PgUpdateWithout<
+	T extends AnyPgUpdate,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	PgUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['returning'],
+		TDynamic,
+		T['_']['excludedMethods'] | K
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type PgUpdateReturningAll<T extends AnyPgUpdate, TDynamic extends boolean> = PgUpdateWithout<
+	PgUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		T['_']['table']['$inferSelect'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type PgUpdateReturning<
+	T extends AnyPgUpdate,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFields,
+> = PgUpdateWithout<
+	PgUpdateBase<
+		T['_']['table'],
+		T['_']['queryResult'],
+		SelectResultFields<TSelectedFields>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type PgUpdatePrepare<T extends AnyPgUpdate> = PreparedQuery<
+	PreparedQueryConfig & {
+		execute: T['_']['returning'] extends undefined ? QueryResultKind<T['_']['queryResult'], never>
+			: T['_']['returning'][];
+	}
+>;
+
+export type PgUpdateDynamic<T extends AnyPgUpdate> = PgUpdate<
+	T['_']['table'],
+	T['_']['queryResult'],
+	T['_']['returning']
+>;
+
+export type PgUpdate<
+	TTable extends PgTable = PgTable,
+	TQueryResult extends QueryResultHKT = QueryResultHKT,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = PgUpdateBase<TTable, TQueryResult, TReturning, true, never>;
+
+type AnyPgUpdate = PgUpdateBase<any, any, any, any, any>;
+
+export interface PgUpdateBase<
 	TTable extends PgTable,
 	TQueryResult extends QueryResultHKT,
 	TReturning extends Record<string, unknown> | undefined = undefined,
-> extends
-	QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>,
-	SQLWrapper
-{}
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>, SQLWrapper {
+	readonly _: {
+		readonly table: TTable;
+		readonly queryResult: TQueryResult;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+	};
+}
 
-export class PgUpdate<
+export class PgUpdateBase<
 	TTable extends PgTable,
 	TQueryResult extends QueryResultHKT,
 	TReturning extends Record<string, unknown> | undefined = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
 > extends QueryPromise<TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[]>
 	implements SQLWrapper
 {
 	static readonly [entityKind]: string = 'PgUpdate';
 
-	declare readonly _: {
-		readonly table: TTable;
-		readonly return: TReturning;
-	};
-
 	private config: PgUpdateConfig;
 
 	constructor(
@@ -85,20 +159,20 @@ export class PgUpdate<
 		this.config = { set, table };
 	}
 
-	where(where: SQL | undefined): this {
+	where(where: SQL | undefined): PgUpdateWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
-	returning(): PgUpdate<TTable, TQueryResult, InferModel<TTable>>;
+	returning(): PgUpdateReturningAll<this, TDynamic>;
 	returning<TSelectedFields extends SelectedFields>(
 		fields: TSelectedFields,
-	): PgUpdate<TTable, TQueryResult, SelectResultFields<TSelectedFields>>;
+	): PgUpdateReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields: SelectedFields = this.config.table[Table.Symbol.Columns],
-	): PgUpdate<TTable, any, any> {
+	): PgUpdateWithout<AnyPgUpdate, TDynamic, 'returning'> {
 		this.config.returning = orderSelectedFields(fields);
-		return this as PgUpdate<TTable, any>;
+		return this as any;
 	}
 
 	/** @internal */
@@ -106,28 +180,24 @@ export class PgUpdate<
 		return this.dialect.buildUpdateQuery(this.config);
 	}
 
-	toSQL(): Omit<Query, 'typings'> {
+	toSQL(): Query {
 		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
 		return rest;
 	}
 
-	private _prepare(name?: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-		}
-	> {
+	private _prepare(name?: string): PgUpdatePrepare<this> {
 		return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name);
 	}
 
-	prepare(name: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TReturning extends undefined ? QueryResultKind<TQueryResult, never> : TReturning[];
-		}
-	> {
+	prepare(name: string): PgUpdatePrepare<this> {
 		return this._prepare(name);
 	}
 
 	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
 		return this._prepare().execute(placeholderValues);
 	};
+
+	$dynamic(): PgUpdateDynamic<this> {
+		return this as any;
+	}
 }
diff --git a/drizzle-orm/src/query-builders/select.types.ts b/drizzle-orm/src/query-builders/select.types.ts
index 8659b0cad..2477ba0ba 100644
--- a/drizzle-orm/src/query-builders/select.types.ts
+++ b/drizzle-orm/src/query-builders/select.types.ts
@@ -3,7 +3,7 @@ import type { AnyColumn, Column, GetColumnData, UpdateColConfig } from '~/column
 import type { SelectedFields } from '~/operations.ts';
 import type { SQL } from '~/sql/index.ts';
 import type { Subquery } from '~/subquery.ts';
-import type { AnyTable, Table } from '~/table.ts';
+import type { Table } from '~/table.ts';
 import type { Assume, DrizzleTypeError, Equal, IsAny, Simplify } from '~/utils.ts';
 import type { ColumnsSelection, View } from '~/view.ts';
 
@@ -49,7 +49,7 @@ type Not<T extends boolean> = T extends true ? false : true;
 type SelectPartialResult<TFields, TNullability extends Record<string, JoinNullability>> = TNullability extends
 	TNullability ? {
 		[Key in keyof TFields]: TFields[Key] extends infer TField
-			? TField extends AnyTable ? TField['_']['name'] extends keyof TNullability ? ApplyNullability<
+			? TField extends Table ? TField['_']['name'] extends keyof TNullability ? ApplyNullability<
 						SelectResultFields<TField['_']['columns']>,
 						TNullability[TField['_']['name']]
 					>
@@ -160,8 +160,8 @@ export type SelectResultField<T, TDeep extends boolean = true> = T extends Drizz
 	: T extends Record<string, any> ? SelectResultFields<T, true>
 	: never;
 
-export type SelectResultFields<TSelectedFields, TDeep extends boolean = true> =
-	& {
+export type SelectResultFields<TSelectedFields, TDeep extends boolean = true> = Simplify<
+	{
 		[Key in keyof TSelectedFields & string]: SelectResultField<TSelectedFields[Key], TDeep>;
 	}
-	& {};
+>;
diff --git a/drizzle-orm/src/runnable-query.ts b/drizzle-orm/src/runnable-query.ts
new file mode 100644
index 000000000..c554daae6
--- /dev/null
+++ b/drizzle-orm/src/runnable-query.ts
@@ -0,0 +1,11 @@
+import type { Dialect } from './column-builder.ts';
+import type { PreparedQuery } from './session.ts';
+
+export interface RunnableQuery<T, TDialect extends Dialect> {
+	readonly _: {
+		readonly dialect: TDialect;
+		readonly result: T;
+	};
+
+	prepare(): PreparedQuery;
+}
diff --git a/drizzle-orm/src/session.ts b/drizzle-orm/src/session.ts
new file mode 100644
index 000000000..128475891
--- /dev/null
+++ b/drizzle-orm/src/session.ts
@@ -0,0 +1,6 @@
+import type { Query } from './index.ts';
+
+export interface PreparedQuery {
+	getQuery(): Query;
+	mapResult(response: unknown, isFromBatch?: boolean): unknown;
+}
diff --git a/drizzle-orm/src/sql-js/session.ts b/drizzle-orm/src/sql-js/session.ts
index f9617e40c..c58fdf396 100644
--- a/drizzle-orm/src/sql-js/session.ts
+++ b/drizzle-orm/src/sql-js/session.ts
@@ -12,7 +12,7 @@ import type {
 	SQLiteExecuteMethod,
 	SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
-import { PreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
+import { SQLitePreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
 
 export interface SQLJsSessionOptions {
@@ -45,7 +45,7 @@ export class SQLJsSession<
 		executeMethod: SQLiteExecuteMethod,
 	): PreparedQuery<T> {
 		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(stmt, query.sql, query.params, this.logger, fields, executeMethod);
+		return new PreparedQuery(stmt, query, this.logger, fields, executeMethod);
 	}
 
 	override prepareOneTimeQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
@@ -57,8 +57,7 @@ export class SQLJsSession<
 		const stmt = this.client.prepare(query.sql);
 		return new PreparedQuery(
 			stmt,
-			query.sql,
-			query.params,
+			query,
 			this.logger,
 			fields,
 			executeMethod,
@@ -112,20 +111,19 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 
 	constructor(
 		private stmt: Statement,
-		private queryString: string,
-		private params: unknown[],
+		query: Query,
 		private logger: Logger,
 		private fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 		private customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
 		private isOneTimeQuery = false,
 	) {
-		super('sync', executeMethod);
+		super('sync', executeMethod, query);
 	}
 
 	run(placeholderValues?: Record<string, unknown>): void {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		const result = this.stmt.run(params as BindParams);
 
 		if (this.isOneTimeQuery) {
@@ -136,10 +134,10 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	all(placeholderValues?: Record<string, unknown>): T['all'] {
-		const { fields, joinsNotNullableMap, logger, queryString, stmt, isOneTimeQuery, customResultMapper } = this;
+		const { fields, joinsNotNullableMap, logger, query, stmt, isOneTimeQuery, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
-			const params = fillPlaceholders(this.params, placeholderValues ?? {});
-			logger.logQuery(queryString, params);
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
 			stmt.bind(params as BindParams);
 			const rows: unknown[] = [];
 			while (stmt.step()) {
@@ -163,8 +161,8 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	get(placeholderValues?: Record<string, unknown>): T['get'] {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 
 		const { fields, stmt, isOneTimeQuery, joinsNotNullableMap, customResultMapper } = this;
 		if (!fields && !customResultMapper) {
@@ -195,8 +193,8 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	values(placeholderValues?: Record<string, unknown>): T['values'] {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
 		this.stmt.bind(params as BindParams);
 		const rows: unknown[] = [];
 		while (this.stmt.step()) {
diff --git a/drizzle-orm/src/sqlite-core/db.ts b/drizzle-orm/src/sqlite-core/db.ts
index 22276f100..a4a9fac21 100644
--- a/drizzle-orm/src/sqlite-core/db.ts
+++ b/drizzle-orm/src/sqlite-core/db.ts
@@ -9,20 +9,26 @@ import type { SQLWrapper } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import {
 	QueryBuilder,
-	SQLiteDelete,
+	SQLiteDeleteBase,
 	SQLiteInsertBuilder,
 	SQLiteSelectBuilder,
 	SQLiteUpdateBuilder,
 } from '~/sqlite-core/query-builders/index.ts';
-import type { DBResult, Result, SQLiteSession, SQLiteTransaction, SQLiteTransactionConfig } from '~/sqlite-core/session.ts';
+import type {
+	DBResult,
+	Result,
+	SQLiteSession,
+	SQLiteTransaction,
+	SQLiteTransactionConfig,
+} from '~/sqlite-core/session.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
 import { type DrizzleTypeError } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { RelationalQueryBuilder } from './query-builders/query.ts';
+import { SQLiteRaw } from './query-builders/raw.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import type { WithSubqueryWithSelection } from './subquery.ts';
-import { SQLiteRaw } from './query-builders/raw.ts';
 
 export class BaseSQLiteDatabase<
 	TResultKind extends 'sync' | 'async',
@@ -95,7 +101,9 @@ export class BaseSQLiteDatabase<
 		function select<TSelection extends SelectedFields>(
 			fields: TSelection,
 		): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-		function select(fields?: SelectedFields): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
+		function select(
+			fields?: SelectedFields,
+		): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
 			return new SQLiteSelectBuilder({
 				fields: fields ?? undefined,
 				session: self.session,
@@ -135,7 +143,9 @@ export class BaseSQLiteDatabase<
 	selectDistinct<TSelection extends SelectedFields>(
 		fields: TSelection,
 	): SQLiteSelectBuilder<TSelection, TResultKind, TRunResult>;
-	selectDistinct(fields?: SelectedFields): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
+	selectDistinct(
+		fields?: SelectedFields,
+	): SQLiteSelectBuilder<SelectedFields | undefined, TResultKind, TRunResult> {
 		return new SQLiteSelectBuilder({
 			fields: fields ?? undefined,
 			session: this.session,
@@ -152,40 +162,64 @@ export class BaseSQLiteDatabase<
 		return new SQLiteInsertBuilder(into, this.session, this.dialect);
 	}
 
-	delete<TTable extends SQLiteTable>(from: TTable): SQLiteDelete<TTable, TResultKind, TRunResult> {
-		return new SQLiteDelete(from, this.session, this.dialect);
+	delete<TTable extends SQLiteTable>(from: TTable): SQLiteDeleteBase<TTable, TResultKind, TRunResult> {
+		return new SQLiteDeleteBase(from, this.session, this.dialect);
 	}
 
 	run(query: SQLWrapper): DBResult<TResultKind, TRunResult> {
 		const sql = query.getSQL();
 		if (this.resultKind === 'async') {
-			return new SQLiteRaw(async () => this.session.run(sql), () => sql, 'run');
+			return new SQLiteRaw(
+				async () => this.session.run(sql),
+				() => sql,
+				'run',
+				this.dialect as SQLiteAsyncDialect,
+				this.session.extractRawRunValueFromBatchResult.bind(this.session),
+			) as DBResult<TResultKind, TRunResult>;
 		}
-		return this.session.run(sql);
+		return this.session.run(sql) as DBResult<TResultKind, TRunResult>;
 	}
 
 	all<T = unknown>(query: SQLWrapper): DBResult<TResultKind, T[]> {
 		const sql = query.getSQL();
 		if (this.resultKind === 'async') {
-			return new SQLiteRaw(async () => this.session.all(sql), () => sql, 'all');
+			return new SQLiteRaw(
+				async () => this.session.all(sql),
+				() => sql,
+				'all',
+				this.dialect as SQLiteAsyncDialect,
+				this.session.extractRawAllValueFromBatchResult.bind(this.session),
+			) as any;
 		}
-		return this.session.all(sql);
+		return this.session.all(sql) as DBResult<TResultKind, T[]>;
 	}
 
 	get<T = unknown>(query: SQLWrapper): DBResult<TResultKind, T> {
 		const sql = query.getSQL();
 		if (this.resultKind === 'async') {
-			return new SQLiteRaw(async () => this.session.get(sql), () => sql, 'get');
+			return new SQLiteRaw(
+				async () => this.session.get(sql),
+				() => sql,
+				'get',
+				this.dialect as SQLiteAsyncDialect,
+				this.session.extractRawGetValueFromBatchResult.bind(this.session),
+			) as DBResult<TResultKind, T>;
 		}
-		return this.session.get(sql);
+		return this.session.get(sql) as DBResult<TResultKind, T>;
 	}
 
 	values<T extends unknown[] = unknown[]>(query: SQLWrapper): DBResult<TResultKind, T[]> {
 		const sql = query.getSQL();
 		if (this.resultKind === 'async') {
-			return new SQLiteRaw(async () => this.session.values(sql), () => sql, 'values');
+			return new SQLiteRaw(
+				async () => this.session.values(sql),
+				() => sql,
+				'values',
+				this.dialect as SQLiteAsyncDialect,
+				this.session.extractRawValuesValueFromBatchResult.bind(this.session),
+			) as any;
 		}
-		return this.session.values(sql);
+		return this.session.values(sql) as DBResult<TResultKind, T[]>;
 	}
 
 	transaction<T>(
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index cc59b3a2b..2744459ed 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -24,7 +24,11 @@ import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view.ts';
-import type { Join, SelectedFieldsOrdered, SQLiteSelectConfig } from './query-builders/select.types.ts';
+import type {
+	SelectedFieldsOrdered,
+	SQLiteSelectConfig,
+	SQLiteSelectJoinConfig,
+} from './query-builders/select.types.ts';
 import type { SQLiteSession } from './session.ts';
 import { SQLiteViewBase } from './view.ts';
 
@@ -352,7 +356,7 @@ export abstract class SQLiteDialect {
 	}): BuildRelationalQueryResult<SQLiteTable, SQLiteColumn> {
 		let selection: BuildRelationalQueryResult<SQLiteTable, SQLiteColumn>['selection'] = [];
 		let limit, offset, orderBy: SQLiteSelectConfig['orderBy'] = [], where;
-		const joins: Join[] = [];
+		const joins: SQLiteSelectJoinConfig[] = [];
 
 		if (config === true) {
 			const selectionEntries = Object.entries(tableConfig.columns);
@@ -519,9 +523,10 @@ export abstract class SQLiteDialect {
 		}
 
 		if (selection.length === 0) {
-			throw new DrizzleError(
-				`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`,
-			);
+			throw new DrizzleError({
+				message:
+					`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`,
+			});
 		}
 
 		let result;
diff --git a/drizzle-orm/src/sqlite-core/query-builders/delete.ts b/drizzle-orm/src/sqlite-core/query-builders/delete.ts
index 4927af1bc..746bb28fb 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/delete.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/delete.ts
@@ -1,38 +1,134 @@
 import { entityKind } from '~/entity.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
-import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
-import type { InferModel } from '~/table.ts';
-import { type DrizzleTypeError, orderSelectedFields, type Simplify } from '~/utils.ts';
+import { type DrizzleTypeError, orderSelectedFields } from '~/utils.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
 
+export type SQLiteDeleteWithout<
+	T extends AnySQLiteDeleteBase,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		SQLiteDeleteBase<
+			T['_']['table'],
+			T['_']['resultType'],
+			T['_']['runResult'],
+			T['_']['returning'],
+			TDynamic,
+			T['_']['excludedMethods'] | K
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type SQLiteDelete<
+	TTable extends SQLiteTable = SQLiteTable,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TReturning extends Record<string, unknown> | undefined = undefined,
+> = SQLiteDeleteBase<TTable, TResultType, TRunResult, TReturning, true, never>;
+
 export interface SQLiteDeleteConfig {
 	where?: SQL | undefined;
 	table: SQLiteTable;
 	returning?: SelectedFieldsOrdered;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface SQLiteDelete<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type SQLiteDeleteReturningAll<
+	T extends AnySQLiteDeleteBase,
+	TDynamic extends boolean,
+> = SQLiteDeleteWithout<
+	SQLiteDeleteBase<
+		T['_']['table'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		T['_']['table']['$inferSelect'],
+		T['_']['dynamic'],
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type SQLiteDeleteReturning<
+	T extends AnySQLiteDeleteBase,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFieldsFlat,
+> = SQLiteDeleteWithout<
+	SQLiteDeleteBase<
+		T['_']['table'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		SelectResultFields<TSelectedFields>,
+		T['_']['dynamic'],
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type SQLiteDeleteExecute<T extends AnySQLiteDeleteBase> = T['_']['returning'] extends undefined
+	? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteDeletePrepare<T extends AnySQLiteDeleteBase> = SQLitePreparedQuery<{
+	type: T['_']['resultType'];
+	run: T['_']['runResult'];
+	all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+		: T['_']['returning'][];
+	get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+		: T['_']['returning'] | undefined;
+	values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+		: any[][];
+	execute: SQLiteDeleteExecute<T>;
+}>;
+
+export type SQLiteDeleteDynamic<T extends AnySQLiteDeleteBase> = SQLiteDelete<
+	T['_']['table'],
+	T['_']['resultType'],
+	T['_']['runResult'],
+	T['_']['returning']
+>;
+
+export type AnySQLiteDeleteBase = SQLiteDeleteBase<any, any, any, any, any, any>;
+
+export interface SQLiteDeleteBase<
 	TTable extends SQLiteTable,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TResultType extends 'sync' | 'async',
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TRunResult,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TReturning = undefined,
-> extends SQLWrapper {}
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends SQLWrapper {
+	readonly _: {
+		dialect: 'sqlite';
+		readonly table: TTable;
+		readonly resultType: TResultType;
+		readonly runResult: TRunResult;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TReturning extends undefined ? TRunResult : TReturning[];
+	};
+}
 
-export class SQLiteDelete<
+export class SQLiteDeleteBase<
 	TTable extends SQLiteTable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TResultType extends 'sync' | 'async',
 	TRunResult,
-	TReturning = undefined,
-> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
+	TReturning extends Record<string, unknown> | undefined = undefined,
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
+	implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper
+{
 	static readonly [entityKind]: string = 'SQLiteDelete';
 
 	/** @internal */
@@ -47,20 +143,20 @@ export class SQLiteDelete<
 		this.config = { table };
 	}
 
-	where(where: SQL | undefined): Omit<this, 'where'> {
+	where(where: SQL | undefined): SQLiteDeleteWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
-	returning(): SQLiteDelete<TTable, TResultType, TRunResult, InferModel<TTable>>;
+	returning(): SQLiteDeleteReturningAll<this, TDynamic>;
 	returning<TSelectedFields extends SelectedFieldsFlat>(
 		fields: TSelectedFields,
-	): SQLiteDelete<TTable, TResultType, TRunResult, Simplify<SelectResultFields<TSelectedFields>>>;
+	): SQLiteDeleteReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields: SelectedFieldsFlat = this.table[SQLiteTable.Symbol.Columns],
-	): SQLiteDelete<TTable, TResultType, TRunResult, any> {
+	): SQLiteDeleteReturning<this, TDynamic, any> {
 		this.config.returning = orderSelectedFields(fields);
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -68,25 +164,17 @@ export class SQLiteDelete<
 		return this.dialect.buildDeleteQuery(this.config);
 	}
 
-	toSQL(): Omit<Query, 'typings'> {
+	toSQL(): Query {
 		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
 		return rest;
 	}
 
-	prepare(isOneTimeQuery?: boolean): PreparedQuery<{
-		type: TResultType;
-		run: TRunResult;
-		all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
-		get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
-			: TReturning | undefined;
-		values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'> : any[][];
-		execute: TReturning extends undefined ? TRunResult : TReturning[];
-	}> {
+	prepare(isOneTimeQuery?: boolean): SQLiteDeletePrepare<this> {
 		return this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
 			this.dialect.sqlToQuery(this.getSQL()),
 			this.config.returning,
 			this.config.returning ? 'all' : 'run',
-		) as ReturnType<this['prepare']>;
+		) as SQLiteDeletePrepare<this>;
 	}
 
 	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
@@ -105,10 +193,11 @@ export class SQLiteDelete<
 		return this.prepare(true).values(placeholderValues);
 	};
 
-	override async execute(
-		placeholderValues?: Record<string, unknown>,
-	): Promise<TReturning extends undefined ? TRunResult : TReturning[]> {
-		return this.prepare(true).execute(placeholderValues) as TReturning extends undefined ? TRunResult
-			: TReturning[];
+	override async execute(placeholderValues?: Record<string, unknown>): Promise<SQLiteDeleteExecute<this>> {
+		return this.prepare(true).execute(placeholderValues) as SQLiteDeleteExecute<this>;
+	}
+
+	$dynamic(): SQLiteDeleteDynamic<this> {
+		return this as any;
 	}
 }
diff --git a/drizzle-orm/src/sqlite-core/query-builders/insert.ts b/drizzle-orm/src/sqlite-core/query-builders/insert.ts
index 4b74ac093..669ee5ac5 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/insert.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/insert.ts
@@ -1,13 +1,14 @@
 import { entityKind, is } from '~/entity.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
 import type { Placeholder, Query, SQLWrapper } from '~/sql/index.ts';
 import { Param, SQL, sql } from '~/sql/index.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { IndexColumn } from '~/sqlite-core/indexes.ts';
-import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
-import { type InferModel, Table } from '~/table.ts';
+import { Table } from '~/table.ts';
 import { type DrizzleTypeError, mapUpdateSet, orderSelectedFields, type Simplify } from '~/utils.ts';
 import type { SelectedFieldsFlat, SelectedFieldsOrdered } from './select.types.ts';
 import type { SQLiteUpdateSetSource } from './update.ts';
@@ -21,7 +22,7 @@ export interface SQLiteInsertConfig<TTable extends SQLiteTable = SQLiteTable> {
 
 export type SQLiteInsertValue<TTable extends SQLiteTable> = Simplify<
 	{
-		[Key in keyof InferModel<TTable, 'insert'>]: InferModel<TTable, 'insert'>[Key] | SQL | Placeholder;
+		[Key in keyof TTable['$inferInsert']]: TTable['$inferInsert'][Key] | SQL | Placeholder;
 	}
 >;
 
@@ -38,11 +39,11 @@ export class SQLiteInsertBuilder<
 		protected dialect: SQLiteDialect,
 	) {}
 
-	values(value: SQLiteInsertValue<TTable>): SQLiteInsert<TTable, TResultType, TRunResult>;
-	values(values: SQLiteInsertValue<TTable>[]): SQLiteInsert<TTable, TResultType, TRunResult>;
+	values(value: SQLiteInsertValue<TTable>): SQLiteInsertBase<TTable, TResultType, TRunResult>;
+	values(values: SQLiteInsertValue<TTable>[]): SQLiteInsertBase<TTable, TResultType, TRunResult>;
 	values(
 		values: SQLiteInsertValue<TTable> | SQLiteInsertValue<TTable>[],
-	): SQLiteInsert<TTable, TResultType, TRunResult> {
+	): SQLiteInsertBase<TTable, TResultType, TRunResult> {
 		values = Array.isArray(values) ? values : [values];
 		if (values.length === 0) {
 			throw new Error('values() must be called with at least one value');
@@ -63,36 +64,134 @@ export class SQLiteInsertBuilder<
 		// 	);
 		// }
 
-		return new SQLiteInsert(this.table, mappedValues, this.session, this.dialect);
+		return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect);
 	}
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface SQLiteInsert<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TTable extends SQLiteTable,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TResultType extends 'sync' | 'async',
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TRunResult,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TReturning = undefined,
-> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {}
+export type SQLiteInsertWithout<T extends AnySQLiteInsert, TDynamic extends boolean, K extends keyof T & string> =
+	TDynamic extends true ? T
+		: Omit<
+			SQLiteInsertBase<
+				T['_']['table'],
+				T['_']['resultType'],
+				T['_']['runResult'],
+				T['_']['returning'],
+				TDynamic,
+				T['_']['excludedMethods'] | K
+			>,
+			T['_']['excludedMethods'] | K
+		>;
+
+export type SQLiteInsertReturning<
+	T extends AnySQLiteInsert,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFieldsFlat,
+> = SQLiteInsertWithout<
+	SQLiteInsertBase<
+		T['_']['table'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		SelectResultFields<TSelectedFields>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type SQLiteInsertReturningAll<
+	T extends AnySQLiteInsert,
+	TDynamic extends boolean,
+> = SQLiteInsertWithout<
+	SQLiteInsertBase<
+		T['_']['table'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		T['_']['table']['$inferSelect'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type SQLiteInsertOnConflictDoUpdateConfig<T extends AnySQLiteInsert> = {
+	target: IndexColumn | IndexColumn[];
+	where?: SQL;
+	set: SQLiteUpdateSetSource<T['_']['table']>;
+};
+
+export type SQLiteInsertDynamic<T extends AnySQLiteInsert> = SQLiteInsert<
+	T['_']['table'],
+	T['_']['resultType'],
+	T['_']['runResult'],
+	T['_']['returning']
+>;
+
+export type SQLiteInsertExecute<T extends AnySQLiteInsert> = T['_']['returning'] extends undefined ? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteInsertPrepare<T extends AnySQLiteInsert> = SQLitePreparedQuery<
+	{
+		type: T['_']['resultType'];
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'];
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteInsertExecute<T>;
+	}
+>;
+
+export type AnySQLiteInsert = SQLiteInsertBase<any, any, any, any, any, any>;
+
+export type SQLiteInsert<
+	TTable extends SQLiteTable = SQLiteTable,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TReturning = any,
+> = SQLiteInsertBase<TTable, TResultType, TRunResult, TReturning, true, never>;
 
-export class SQLiteInsert<
+export interface SQLiteInsertBase<
 	TTable extends SQLiteTable,
 	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TReturning = undefined,
-> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
-	static readonly [entityKind]: string = 'SQLiteInsert';
-
-	declare readonly _: {
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends
+	SQLWrapper,
+	QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>,
+	RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>
+{
+	readonly _: {
+		readonly dialect: 'sqlite';
 		readonly table: TTable;
 		readonly resultType: TResultType;
 		readonly runResult: TRunResult;
 		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TReturning extends undefined ? TRunResult : TReturning[];
 	};
+}
+
+export class SQLiteInsertBase<
+	TTable extends SQLiteTable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TReturning = undefined,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
+	implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper
+{
+	static readonly [entityKind]: string = 'SQLiteInsert';
 
 	/** @internal */
 	config: SQLiteInsertConfig<TTable>;
@@ -107,15 +206,15 @@ export class SQLiteInsert<
 		this.config = { table, values };
 	}
 
-	returning(): SQLiteInsert<TTable, TResultType, TRunResult, InferModel<TTable>>;
+	returning(): SQLiteInsertReturningAll<this, TDynamic>;
 	returning<TSelectedFields extends SelectedFieldsFlat>(
 		fields: TSelectedFields,
-	): SQLiteInsert<TTable, TResultType, TRunResult, Simplify<SelectResultFields<TSelectedFields>>>;
+	): SQLiteInsertReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields: SelectedFieldsFlat = this.config.table[SQLiteTable.Symbol.Columns],
-	): SQLiteInsert<TTable, TResultType, TRunResult, any> {
+	): SQLiteInsertWithout<AnySQLiteInsert, TDynamic, 'returning'> {
 		this.config.returning = orderSelectedFields(fields);
-		return this;
+		return this as any;
 	}
 
 	onConflictDoNothing(config: { target?: IndexColumn | IndexColumn[]; where?: SQL } = {}): this {
@@ -129,11 +228,7 @@ export class SQLiteInsert<
 		return this;
 	}
 
-	onConflictDoUpdate(config: {
-		target: IndexColumn | IndexColumn[];
-		where?: SQL;
-		set: SQLiteUpdateSetSource<TTable>;
-	}): this {
+	onConflictDoUpdate(config: SQLiteInsertOnConflictDoUpdateConfig<this>): this {
 		const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
 		const whereSql = config.where ? sql` where ${config.where}` : sql``;
 		const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
@@ -146,27 +241,17 @@ export class SQLiteInsert<
 		return this.dialect.buildInsertQuery(this.config);
 	}
 
-	toSQL(): Simplify<Query> {
+	toSQL(): Query {
 		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
 		return rest;
 	}
 
-	prepare(isOneTimeQuery?: boolean): PreparedQuery<
-		{
-			type: TResultType;
-			run: TRunResult;
-			all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
-			get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'> : TReturning;
-			values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
-				: any[][];
-			execute: TReturning extends undefined ? TRunResult : TReturning[];
-		}
-	> {
+	prepare(isOneTimeQuery?: boolean): SQLiteInsertPrepare<this> {
 		return this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
 			this.dialect.sqlToQuery(this.getSQL()),
 			this.config.returning,
 			this.config.returning ? 'all' : 'run',
-		) as ReturnType<this['prepare']>;
+		) as SQLiteInsertPrepare<this>;
 	}
 
 	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
@@ -185,8 +270,11 @@ export class SQLiteInsert<
 		return this.prepare(true).values(placeholderValues);
 	};
 
-	override async execute(): Promise<TReturning extends undefined ? TRunResult : TReturning[]> {
-		return (this.config.returning ? this.all() : this.run()) as TReturning extends undefined ? TRunResult
-			: TReturning[];
+	override async execute(): Promise<SQLiteInsertExecute<this>> {
+		return (this.config.returning ? this.all() : this.run()) as SQLiteInsertExecute<this>;
+	}
+
+	$dynamic(): SQLiteInsertDynamic<this> {
+		return this as any;
 	}
 }
diff --git a/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts b/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
index 069588361..1e30669bd 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
@@ -69,7 +69,9 @@ export class QueryBuilder {
 	}
 
 	select(): SQLiteSelectBuilder<undefined, 'sync', void, 'qb'>;
-	select<TSelection extends SelectedFields>(fields: TSelection): SQLiteSelectBuilder<TSelection, 'sync', void, 'qb'>;
+	select<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): SQLiteSelectBuilder<TSelection, 'sync', void, 'qb'>;
 	select<TSelection extends SelectedFields>(
 		fields?: TSelection,
 	): SQLiteSelectBuilder<TSelection | undefined, 'sync', void, 'qb'> {
diff --git a/drizzle-orm/src/sqlite-core/query-builders/query.ts b/drizzle-orm/src/sqlite-core/query-builders/query.ts
index 186db52cd..a7a100f7d 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/query.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/query.ts
@@ -8,10 +8,11 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
 import { type Query, type QueryWithTypings, type SQL, type SQLWrapper } from '~/sql/index.ts';
 import { type KnownKeysOnly } from '~/utils.ts';
 import { type SQLiteDialect } from '../dialect.ts';
-import type { PreparedQuery, PreparedQueryConfig, SQLiteSession } from '../session.ts';
+import type { PreparedQueryConfig, SQLitePreparedQuery, SQLiteSession } from '../session.ts';
 import { type SQLiteTable } from '../table.ts';
 
 export type SQLiteRelationalQueryKind<TMode extends 'sync' | 'async', TResult> = TMode extends 'async'
@@ -94,10 +95,16 @@ export class RelationalQueryBuilder<
 	}
 }
 
-export class SQLiteRelationalQuery<TType extends 'sync' | 'async', TResult> extends QueryPromise<TResult> implements SQLWrapper {
+export class SQLiteRelationalQuery<TType extends 'sync' | 'async', TResult> extends QueryPromise<TResult>
+	implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper
+{
 	static readonly [entityKind]: string = 'SQLiteAsyncRelationalQuery';
 
-	declare protected $brand: 'SQLiteRelationalQuery';
+	declare readonly _: {
+		readonly dialect: 'sqlite';
+		readonly type: TType;
+		readonly result: TResult;
+	};
 
 	/** @internal */
 	mode: 'many' | 'first';
@@ -130,7 +137,7 @@ export class SQLiteRelationalQuery<TType extends 'sync' | 'async', TResult> exte
 		}).sql as SQL;
 	}
 
-	prepare(): PreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }> {
+	prepare(): SQLitePreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }> {
 		const { query, builtQuery } = this._toSQL();
 
 		return this.session.prepareQuery(
@@ -146,7 +153,7 @@ export class SQLiteRelationalQuery<TType extends 'sync' | 'async', TResult> exte
 				}
 				return rows as TResult;
 			},
-		) as PreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }>;
+		) as SQLitePreparedQuery<PreparedQueryConfig & { type: TType; all: TResult; get: TResult; execute: TResult }>;
 	}
 
 	private _toSQL(): { query: BuildRelationalQueryResult; builtQuery: QueryWithTypings } {
diff --git a/drizzle-orm/src/sqlite-core/query-builders/raw.ts b/drizzle-orm/src/sqlite-core/query-builders/raw.ts
index 04448c4b1..b5a1223e2 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/raw.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/raw.ts
@@ -1,22 +1,32 @@
 import { entityKind } from '~/entity.ts';
 import type { SQL, SQLWrapper } from '~/index.ts';
 import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { PreparedQuery } from '~/session.ts';
+import type { SQLiteAsyncDialect } from '../dialect.ts';
 
 type SQLiteRawAction = 'all' | 'get' | 'values' | 'run';
 export interface SQLiteRawConfig {
 	action: SQLiteRawAction;
 }
 
-export class SQLiteRaw<TRunResult> extends QueryPromise<TRunResult> implements SQLWrapper {
+export class SQLiteRaw<TResult> extends QueryPromise<TResult> implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper {
 	static readonly [entityKind]: string = 'SQLiteRaw';
 
+	declare readonly _: {
+		readonly dialect: 'sqlite';
+		readonly result: TResult;
+	};
+
 	/** @internal */
 	config: SQLiteRawConfig;
 
 	constructor(
-		private cb: () => Promise<TRunResult>,
+		private cb: () => Promise<TResult>,
 		private getSQLCb: () => SQL,
 		action: SQLiteRawAction,
+		private dialect: SQLiteAsyncDialect,
+		private mapBatchResult: (result: unknown) => unknown,
 	) {
 		super();
 		this.config = { action };
@@ -27,7 +37,18 @@ export class SQLiteRaw<TRunResult> extends QueryPromise<TRunResult> implements S
 		return this.getSQLCb();
 	}
 
-	override async execute(): Promise<TRunResult> {
+	override async execute(): Promise<TResult> {
 		return this.cb();
 	}
+
+	prepare(): PreparedQuery {
+		return {
+			getQuery: () => {
+				return this.dialect.sqlToQuery(this.getSQL());
+			},
+			mapResult: (result: unknown, isFromBatch?: boolean) => {
+				return isFromBatch ? this.mapBatchResult(result) : result;
+			},
+		};
+	}
 }
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.ts b/drizzle-orm/src/sqlite-core/query-builders/select.ts
index 9baa3dcd4..0502b88bf 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.ts
@@ -10,43 +10,31 @@ import type {
 	SelectResult,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
 import { type Placeholder, type Query, SQL } from '~/sql/index.ts';
 import type { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
-import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLiteSession } from '~/sqlite-core/session.ts';
 import type { SubqueryWithSelection } from '~/sqlite-core/subquery.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
-import {
-	applyMixins,
-	getTableColumns,
-	getTableLikeName,
-	orderSelectedFields,
-	type PromiseOf,
-	type ValueOrArray,
-} from '~/utils.ts';
+import { applyMixins, getTableColumns, getTableLikeName, orderSelectedFields, type ValueOrArray } from '~/utils.ts';
 import { type ColumnsSelection, View, ViewBaseConfig } from '~/view.ts';
 import { SQLiteViewBase } from '../view.ts';
 import type {
-	JoinFn,
+	CreateSQLiteSelectFromBuilderMode,
 	SelectedFields,
+	SQLiteJoinFn,
 	SQLiteSelectConfig,
+	SQLiteSelectDynamic,
+	SQLiteSelectExecute,
 	SQLiteSelectHKT,
 	SQLiteSelectHKTBase,
-	SQLiteSelectQueryBuilderHKT,
+	SQLiteSelectPrepare,
+	SQLiteSelectWithout,
 } from './select.types.ts';
 
-type CreateSQLiteSelectFromBuilderMode<
-	TBuilderMode extends 'db' | 'qb',
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-> = TBuilderMode extends 'db' ? SQLiteSelect<TTableName, TResultType, TRunResult, TSelection, TSelectMode>
-	: SQLiteSelectQueryBuilder<SQLiteSelectQueryBuilderHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode>;
-
 export class SQLiteSelectBuilder<
 	TSelection extends SelectedFields | undefined,
 	TResultType extends 'sync' | 'async',
@@ -107,7 +95,7 @@ export class SQLiteSelectBuilder<
 			fields = getTableColumns<SQLiteTable>(source);
 		}
 
-		return new SQLiteSelect({
+		return new SQLiteSelectBase({
 			table: source,
 			fields,
 			isPartialSelect,
@@ -119,7 +107,7 @@ export class SQLiteSelectBuilder<
 	}
 }
 
-export abstract class SQLiteSelectQueryBuilder<
+export abstract class SQLiteSelectQueryBuilderBase<
 	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
@@ -128,17 +116,26 @@ export abstract class SQLiteSelectQueryBuilder<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-> {
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'SQLiteSelectQueryBuilder';
 
 	override readonly _: {
-		readonly selectMode: TSelectMode;
+		dialect: 'sqlite';
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly resultType: TResultType;
+		readonly runResult: TRunResult;
 		readonly selection: TSelection;
-		readonly result: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-		readonly selectedFields: BuildSubquerySelection<TSelection, TNullabilityMap>;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
 	};
 
 	/** @internal */
@@ -171,7 +168,7 @@ export abstract class SQLiteSelectQueryBuilder<
 		this.session = session;
 		this.dialect = dialect;
 		this._ = {
-			selectedFields: fields as BuildSubquerySelection<TSelection, TNullabilityMap>,
+			selectedFields: fields as TSelectedFields,
 		} as this['_'];
 		this.tableName = getTableLikeName(table);
 		this.joinsNotNullableMap = typeof this.tableName === 'string' ? { [this.tableName]: true } : {};
@@ -179,7 +176,7 @@ export abstract class SQLiteSelectQueryBuilder<
 
 	private createJoin<TJoinType extends JoinType>(
 		joinType: TJoinType,
-	): JoinFn<THKT, TTableName, TResultType, TRunResult, TSelectMode, TJoinType, TSelection, TNullabilityMap> {
+	): SQLiteJoinFn<this, TDynamic, TJoinType> {
 		return (
 			table: SQLiteTable | Subquery | SQLiteViewBase | SQL,
 			on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
@@ -249,7 +246,7 @@ export abstract class SQLiteSelectQueryBuilder<
 				}
 			}
 
-			return this;
+			return this as any;
 		};
 	}
 
@@ -261,7 +258,9 @@ export abstract class SQLiteSelectQueryBuilder<
 
 	fullJoin = this.createJoin('full');
 
-	where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this {
+	where(
+		where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
+	): SQLiteSelectWithout<this, TDynamic, 'where'> {
 		if (typeof where === 'function') {
 			where = where(
 				new Proxy(
@@ -271,10 +270,12 @@ export abstract class SQLiteSelectQueryBuilder<
 			);
 		}
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
-	having(having: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): this {
+	having(
+		having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
+	): SQLiteSelectWithout<this, TDynamic, 'having'> {
 		if (typeof having === 'function') {
 			having = having(
 				new Proxy(
@@ -284,16 +285,18 @@ export abstract class SQLiteSelectQueryBuilder<
 			);
 		}
 		this.config.having = having;
-		return this;
+		return this as any;
 	}
 
-	groupBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
-	groupBy(...columns: (SQLiteColumn | SQL)[]): this;
+	groupBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>,
+	): SQLiteSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(...columns: (SQLiteColumn | SQL)[]): SQLiteSelectWithout<this, TDynamic, 'groupBy'>;
 	groupBy(
 		...columns:
-			| [(aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
+			| [(aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
 			| (SQLiteColumn | SQL | SQL.Aliased)[]
-	): this {
+	): SQLiteSelectWithout<this, TDynamic, 'groupBy'> {
 		if (typeof columns[0] === 'function') {
 			const groupBy = columns[0](
 				new Proxy(
@@ -305,16 +308,18 @@ export abstract class SQLiteSelectQueryBuilder<
 		} else {
 			this.config.groupBy = columns as (SQLiteColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
-	orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
-	orderBy(...columns: (SQLiteColumn | SQL)[]): this;
+	orderBy(
+		builder: (aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>,
+	): SQLiteSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (SQLiteColumn | SQL)[]): SQLiteSelectWithout<this, TDynamic, 'orderBy'>;
 	orderBy(
 		...columns:
-			| [(aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
+			| [(aliases: this['_']['selection']) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
 			| (SQLiteColumn | SQL | SQL.Aliased)[]
-	): this {
+	): SQLiteSelectWithout<this, TDynamic, 'orderBy'> {
 		if (typeof columns[0] === 'function') {
 			const orderBy = columns[0](
 				new Proxy(
@@ -326,17 +331,17 @@ export abstract class SQLiteSelectQueryBuilder<
 		} else {
 			this.config.orderBy = columns as (SQLiteColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
-	limit(limit: number | Placeholder): this {
+	limit(limit: number | Placeholder): SQLiteSelectWithout<this, TDynamic, 'limit'> {
 		this.config.limit = limit;
-		return this;
+		return this as any;
 	}
 
-	offset(offset: number | Placeholder): this {
+	offset(offset: number | Placeholder): SQLiteSelectWithout<this, TDynamic, 'offset'> {
 		this.config.offset = offset;
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -351,23 +356,28 @@ export abstract class SQLiteSelectQueryBuilder<
 
 	as<TAlias extends string>(
 		alias: TAlias,
-	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias> {
+	): SubqueryWithSelection<this['_']['selectedFields'], TAlias> {
 		return new Proxy(
 			new Subquery(this.getSQL(), this.config.fields, alias),
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
+		) as SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
 	}
 
-	override getSelectedFields(): BuildSubquerySelection<TSelection, TNullabilityMap> {
+	/** @internal */
+	override getSelectedFields(): this['_']['selectedFields'] {
 		return new Proxy(
 			this.config.fields,
 			new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as BuildSubquerySelection<TSelection, TNullabilityMap>;
+		) as this['_']['selectedFields'];
+	}
+
+	$dynamic(): SQLiteSelectDynamic<this> {
+		return this;
 	}
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface SQLiteSelect<
+export interface SQLiteSelectBase<
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
 	TRunResult,
@@ -375,20 +385,28 @@ export interface SQLiteSelect<
 	TSelectMode extends SelectMode = 'single',
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	SQLiteSelectQueryBuilder<
+	SQLiteSelectQueryBuilderBase<
 		SQLiteSelectHKT,
-		TTableName | undefined,
+		TTableName,
 		TResultType,
 		TRunResult,
 		TSelection,
 		TSelectMode,
-		TNullabilityMap
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
 	>,
-	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	QueryPromise<TResult>
 {}
 
-export class SQLiteSelect<
+export class SQLiteSelectBase<
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
 	TRunResult,
@@ -396,27 +414,26 @@ export class SQLiteSelect<
 	TSelectMode extends SelectMode = 'single',
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends SQLiteSelectQueryBuilder<
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends SQLiteSelectQueryBuilderBase<
 	SQLiteSelectHKT,
 	TTableName,
 	TResultType,
 	TRunResult,
 	TSelection,
 	TSelectMode,
-	TNullabilityMap
-> {
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+> implements RunnableQuery<TResult, 'sqlite'> {
 	static readonly [entityKind]: string = 'SQLiteSelect';
 
-	prepare(isOneTimeQuery?: boolean): PreparedQuery<
-		{
-			type: TResultType;
-			run: TRunResult;
-			all: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-			get: SelectResult<TSelection, TSelectMode, TNullabilityMap> | undefined;
-			values: any[][];
-			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
-		}
-	> {
+	prepare(isOneTimeQuery?: boolean): SQLiteSelectPrepare<this> {
 		if (!this.session) {
 			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
 		}
@@ -446,9 +463,9 @@ export class SQLiteSelect<
 		return this.prepare(true).values(placeholderValues);
 	};
 
-	async execute(): Promise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
-		return this.all() as PromiseOf<ReturnType<this['execute']>>;
+	async execute(): Promise<SQLiteSelectExecute<this>> {
+		return this.all() as SQLiteSelectExecute<this>;
 	}
 }
 
-applyMixins(SQLiteSelect, [QueryPromise]);
+applyMixins(SQLiteSelectBase, [QueryPromise]);
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 9ad5ff436..62260b8e4 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -12,27 +12,28 @@ import type {
 import type {
 	AppendToNullabilityMap,
 	AppendToResult,
+	BuildSubquerySelection,
 	GetSelectTableName,
 	JoinNullability,
 	JoinType,
 	MapColumnsToTableAlias,
 	SelectMode,
+	SelectResult,
 } from '~/query-builders/select.types.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import { type ColumnsSelection, type View } from '~/view.ts';
+import type { SQLitePreparedQuery } from '../session.ts';
 import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.ts';
-import type { SQLiteSelect, SQLiteSelectQueryBuilder } from './select.ts';
+import type { SQLiteSelectBase, SQLiteSelectQueryBuilderBase } from './select.ts';
 
-export interface Join {
+export interface SQLiteSelectJoinConfig {
 	on: SQL | undefined;
 	table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
 	alias: string | undefined;
 	joinType: JoinType;
 }
 
-export type AnySQLiteSelect = SQLiteSelect<any, any, any, any, any, any>;
-
 export type BuildAliasTable<TTable extends SQLiteTable | View, TAlias extends string> = TTable extends Table
 	? SQLiteTableWithColumns<
 		UpdateTableConfig<TTable['_']['config'], {
@@ -56,41 +57,54 @@ export interface SQLiteSelectConfig {
 	table: SQLiteTable | Subquery | SQLiteViewBase | SQL;
 	limit?: number | Placeholder;
 	offset?: number | Placeholder;
-	joins?: Join[];
+	joins?: SQLiteSelectJoinConfig[];
 	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
 	groupBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
 	distinct?: boolean;
 }
 
-export type JoinFn<
-	THKT extends SQLiteSelectHKTBase,
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelectMode extends SelectMode,
+export type SQLiteJoin<
+	T extends AnySQLiteSelectQueryBuilder,
+	TDynamic extends boolean,
+	TJoinType extends JoinType,
+	TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL,
+	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
+> = T extends any ? SQLiteSelectWithout<
+		SQLiteSelectKind<
+			T['_']['hkt'],
+			T['_']['tableName'],
+			T['_']['resultType'],
+			T['_']['runResult'],
+			AppendToResult<
+				T['_']['tableName'],
+				T['_']['selection'],
+				TJoinedName,
+				TJoinedTable extends SQLiteTable ? TJoinedTable['_']['columns']
+					: TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: never,
+				T['_']['selectMode']
+			>,
+			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
+			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
+			T['_']['dynamic'],
+			T['_']['excludedMethods']
+		>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>
+	: never;
+
+export type SQLiteJoinFn<
+	T extends AnySQLiteSelectQueryBuilder,
+	TDynamic extends boolean,
 	TJoinType extends JoinType,
-	TSelection,
-	TNullabilityMap extends Record<string, JoinNullability>,
 > = <
 	TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL,
 	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
->(table: TJoinedTable, on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined) => SQLiteSelectKind<
-	THKT,
-	TTableName,
-	TResultType,
-	TRunResult,
-	AppendToResult<
-		TTableName,
-		TSelection,
-		TJoinedName,
-		TJoinedTable extends SQLiteTable ? TJoinedTable['_']['columns']
-			: TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
-			: never,
-		TSelectMode
-	>,
-	TSelectMode extends 'partial' ? TSelectMode : 'multiple',
-	AppendToNullabilityMap<TNullabilityMap, TJoinedName, TJoinType>
->;
+>(
+	table: TJoinedTable,
+	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
+) => SQLiteJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
 
 export type SelectedFieldsFlat = SelectFieldsFlatBase<SQLiteColumn>;
 
@@ -105,6 +119,10 @@ export interface SQLiteSelectHKTBase {
 	selection: unknown;
 	selectMode: SelectMode;
 	nullabilityMap: unknown;
+	dynamic: boolean;
+	excludedMethods: string;
+	result: unknown;
+	selectedFields: unknown;
 	_type: unknown;
 }
 
@@ -113,9 +131,13 @@ export type SQLiteSelectKind<
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
 	TRunResult,
-	TSelection,
+	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability>,
+	TDynamic extends boolean,
+	TExcludedMethods extends string,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > = (T & {
 	tableName: TTableName;
 	resultType: TResultType;
@@ -123,27 +145,159 @@ export type SQLiteSelectKind<
 	selection: TSelection;
 	selectMode: TSelectMode;
 	nullabilityMap: TNullabilityMap;
+	dynamic: TDynamic;
+	excludedMethods: TExcludedMethods;
+	result: TResult;
+	selectedFields: TSelectedFields;
 })['_type'];
 
 export interface SQLiteSelectQueryBuilderHKT extends SQLiteSelectHKTBase {
-	_type: SQLiteSelectQueryBuilder<
-		this,
+	_type: SQLiteSelectQueryBuilderBase<
+		SQLiteSelectQueryBuilderHKT,
 		this['tableName'],
 		this['resultType'],
 		this['runResult'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		this['result'],
+		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
 
 export interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
-	_type: SQLiteSelect<
+	_type: SQLiteSelectBase<
 		this['tableName'],
 		this['resultType'],
 		this['runResult'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
-		Assume<this['nullabilityMap'], Record<string, JoinNullability>>
+		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
+		this['dynamic'],
+		this['excludedMethods'],
+		this['result'],
+		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
+
+export type CreateSQLiteSelectFromBuilderMode<
+	TBuilderMode extends 'db' | 'qb',
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+> = TBuilderMode extends 'db' ? SQLiteSelectBase<
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode
+	>
+	: SQLiteSelectQueryBuilderBase<
+		SQLiteSelectQueryBuilderHKT,
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode
+	>;
+
+export type SQLiteSelectWithout<
+	T extends AnySQLiteSelectQueryBuilder,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	SQLiteSelectKind<
+		T['_']['hkt'],
+		T['_']['tableName'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		T['_']['selection'],
+		T['_']['selectMode'],
+		T['_']['nullabilityMap'],
+		TDynamic,
+		T['_']['excludedMethods'] | K,
+		T['_']['result'],
+		T['_']['selectedFields']
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type SQLiteSelectExecute<T extends AnySQLiteSelect> = T['_']['result'];
+
+export type SQLiteSelectPrepare<T extends AnySQLiteSelect> = SQLitePreparedQuery<
+	{
+		type: T['_']['resultType'];
+		run: T['_']['runResult'];
+		all: T['_']['result'];
+		get: T['_']['result'][number] | undefined;
+		values: any[][];
+		execute: SQLiteSelectExecute<T>;
+	}
+>;
+
+export type SQLiteSelectDynamic<T extends AnySQLiteSelectQueryBuilder> = SQLiteSelectKind<
+	T['_']['hkt'],
+	T['_']['tableName'],
+	T['_']['resultType'],
+	T['_']['runResult'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
+
+export type SQLiteSelectQueryBuilder<
+	THKT extends SQLiteSelectHKTBase = SQLiteSelectQueryBuilderHKT,
+	TTableName extends string | undefined = string | undefined,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+	TResult = unknown,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> = SQLiteSelectQueryBuilderBase<
+	THKT,
+	TTableName,
+	TResultType,
+	TRunResult,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	never,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnySQLiteSelectQueryBuilder = SQLiteSelectQueryBuilderBase<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type SQLiteSelect<
+	TTableName extends string | undefined = string | undefined,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = SQLiteSelectBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnySQLiteSelect = SQLiteSelectBase<any, any, any, any, any, any, any, any, any, any>;
diff --git a/drizzle-orm/src/sqlite-core/query-builders/update.ts b/drizzle-orm/src/sqlite-core/query-builders/update.ts
index 644d5a481..aaafada7e 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/update.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/update.ts
@@ -2,12 +2,12 @@ import type { GetColumnData } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
-import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
-import type { InferModel } from '~/table.ts';
-import { type DrizzleTypeError, mapUpdateSet, orderSelectedFields, type UpdateSet, type Simplify } from '~/utils.ts';
+import { type DrizzleTypeError, mapUpdateSet, orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import type { SelectedFields, SelectedFieldsOrdered } from './select.types.ts';
 
 export interface SQLiteUpdateConfig {
@@ -42,35 +42,125 @@ export class SQLiteUpdateBuilder<
 		protected dialect: SQLiteDialect,
 	) {}
 
-	set(values: SQLiteUpdateSetSource<TTable>): SQLiteUpdate<TTable, TResultType, TRunResult> {
-		return new SQLiteUpdate(this.table, mapUpdateSet(this.table, values), this.session, this.dialect);
+	set(values: SQLiteUpdateSetSource<TTable>): SQLiteUpdateBase<TTable, TResultType, TRunResult> {
+		return new SQLiteUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect);
 	}
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface SQLiteUpdate<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TTable extends SQLiteTable,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TResultType extends 'sync' | 'async',
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TRunResult,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type SQLiteUpdateWithout<
+	T extends AnySQLiteUpdate,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T : Omit<
+	SQLiteUpdateBase<
+		T['_']['table'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		T['_']['returning'],
+		TDynamic,
+		T['_']['excludedMethods'] | K
+	>,
+	T['_']['excludedMethods'] | K
+>;
+
+export type SQLiteUpdateReturningAll<T extends AnySQLiteUpdate, TDynamic extends boolean> = SQLiteUpdateWithout<
+	SQLiteUpdateBase<
+		T['_']['table'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		T['_']['table']['$inferSelect'],
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type SQLiteUpdateReturning<
+	T extends AnySQLiteUpdate,
+	TDynamic extends boolean,
+	TSelectedFields extends SelectedFields,
+> = SQLiteUpdateWithout<
+	SQLiteUpdateBase<
+		T['_']['table'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		SelectResultFields<TSelectedFields>,
+		TDynamic,
+		T['_']['excludedMethods']
+	>,
+	TDynamic,
+	'returning'
+>;
+
+export type SQLiteUpdateExecute<T extends AnySQLiteUpdate> = T['_']['returning'] extends undefined ? T['_']['runResult']
+	: T['_']['returning'][];
+
+export type SQLiteUpdatePrepare<T extends AnySQLiteUpdate> = SQLitePreparedQuery<
+	{
+		type: T['_']['resultType'];
+		run: T['_']['runResult'];
+		all: T['_']['returning'] extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'>
+			: T['_']['returning'][];
+		get: T['_']['returning'] extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'>
+			: T['_']['returning'];
+		values: T['_']['returning'] extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
+			: any[][];
+		execute: SQLiteUpdateExecute<T>;
+	}
+>;
+
+export type SQLiteUpdateDynamic<T extends AnySQLiteUpdate> = SQLiteUpdate<
+	T['_']['table'],
+	T['_']['resultType'],
+	T['_']['runResult'],
+	T['_']['returning']
+>;
+
+export type SQLiteUpdate<
+	TTable extends SQLiteTable = SQLiteTable,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = any,
+	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
+> = SQLiteUpdateBase<TTable, TResultType, TRunResult, TReturning, true, never>;
+
+type AnySQLiteUpdate = SQLiteUpdateBase<any, any, any, any, any, any>;
+
+export interface SQLiteUpdateBase<
+	TTable extends SQLiteTable = SQLiteTable,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
 	TReturning = undefined,
-> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {}
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {
+	readonly _: {
+		readonly dialect: 'sqlite';
+		readonly table: TTable;
+		readonly resultType: TResultType;
+		readonly runResult: TRunResult;
+		readonly returning: TReturning;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TReturning extends undefined ? TRunResult : TReturning[];
+	};
+}
 
-export class SQLiteUpdate<
-	TTable extends SQLiteTable,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
+export class SQLiteUpdateBase<
+	TTable extends SQLiteTable = SQLiteTable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
 	TReturning = undefined,
-> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]>
+	implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], 'sqlite'>, SQLWrapper
+{
 	static readonly [entityKind]: string = 'SQLiteUpdate';
 
-	declare readonly _: {
-		readonly table: TTable;
-	};
-
 	/** @internal */
 	config: SQLiteUpdateConfig;
 
@@ -84,20 +174,20 @@ export class SQLiteUpdate<
 		this.config = { set, table };
 	}
 
-	where(where: SQL | undefined): Omit<this, 'where'> {
+	where(where: SQL | undefined): SQLiteUpdateWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
-		return this;
+		return this as any;
 	}
 
-	returning(): SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>>;
+	returning(): SQLiteUpdateReturningAll<this, TDynamic>;
 	returning<TSelectedFields extends SelectedFields>(
 		fields: TSelectedFields,
-	): SQLiteUpdate<TTable, TResultType, TRunResult, Simplify<SelectResultFields<TSelectedFields>>>;
+	): SQLiteUpdateReturning<this, TDynamic, TSelectedFields>;
 	returning(
 		fields: SelectedFields = this.config.table[SQLiteTable.Symbol.Columns],
-	): SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>> {
+	): SQLiteUpdateWithout<AnySQLiteUpdate, TDynamic, 'returning'> {
 		this.config.returning = orderSelectedFields(fields);
-		return this as SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>>;
+		return this as any;
 	}
 
 	/** @internal */
@@ -110,22 +200,12 @@ export class SQLiteUpdate<
 		return rest;
 	}
 
-	prepare(isOneTimeQuery?: boolean): PreparedQuery<
-		{
-			type: TResultType;
-			run: TRunResult;
-			all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
-			get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'> : TReturning;
-			values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'>
-				: any[][];
-			execute: TReturning extends undefined ? TRunResult : TReturning[];
-		}
-	> {
+	prepare(isOneTimeQuery?: boolean): SQLiteUpdatePrepare<this> {
 		return this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
 			this.dialect.sqlToQuery(this.getSQL()),
 			this.config.returning,
 			this.config.returning ? 'all' : 'run',
-		) as ReturnType<this['prepare']>;
+		) as SQLiteUpdatePrepare<this>;
 	}
 
 	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
@@ -144,8 +224,11 @@ export class SQLiteUpdate<
 		return this.prepare(true).values(placeholderValues);
 	};
 
-	override async execute(): Promise<TReturning extends undefined ? TRunResult : TReturning[]> {
-		return (this.config.returning ? this.all() : this.run()) as TReturning extends undefined ? TRunResult
-			: TReturning[];
+	override async execute(): Promise<SQLiteUpdateExecute<this>> {
+		return (this.config.returning ? this.all() : this.run()) as SQLiteUpdateExecute<this>;
+	}
+
+	$dynamic(): SQLiteUpdateDynamic<this> {
+		return this as any;
 	}
 }
diff --git a/drizzle-orm/src/sqlite-core/session.ts b/drizzle-orm/src/sqlite-core/session.ts
index f443232b1..0f221d8b4 100644
--- a/drizzle-orm/src/sqlite-core/session.ts
+++ b/drizzle-orm/src/sqlite-core/session.ts
@@ -1,12 +1,13 @@
 import { entityKind } from '~/entity.ts';
 import { DrizzleError, TransactionRollbackError } from '~/errors.ts';
 import { type TablesRelationalConfig } from '~/relations.ts';
+import type { PreparedQuery } from '~/session.ts';
 import type { Query, SQL } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { QueryPromise } from '../index.ts';
 import { BaseSQLiteDatabase } from './db.ts';
-import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
 import type { SQLiteRaw } from './query-builders/raw.ts';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
 
 export interface PreparedQueryConfig {
 	type: 'sync' | 'async';
@@ -36,7 +37,7 @@ export class ExecuteResultSync<T> extends QueryPromise<T> {
 export type ExecuteResult<TType extends 'sync' | 'async', TResult> = TType extends 'async' ? Promise<TResult>
 	: ExecuteResultSync<TResult>;
 
-export abstract class PreparedQuery<T extends PreparedQueryConfig> {
+export abstract class SQLitePreparedQuery<T extends PreparedQueryConfig> implements PreparedQuery {
 	static readonly [entityKind]: string = 'PreparedQuery';
 
 	/** @internal */
@@ -45,14 +46,31 @@ export abstract class PreparedQuery<T extends PreparedQueryConfig> {
 	constructor(
 		private mode: 'sync' | 'async',
 		private executeMethod: SQLiteExecuteMethod,
+		protected query: Query,
 	) {}
 
+	getQuery(): Query {
+		return this.query;
+	}
+
 	abstract run(placeholderValues?: Record<string, unknown>): Result<T['type'], T['run']>;
 
+	mapRunResult(result: unknown, _isFromBatch?: boolean): unknown {
+		return result;
+	}
+
 	abstract all(placeholderValues?: Record<string, unknown>): Result<T['type'], T['all']>;
 
+	mapAllResult(_result: unknown, _isFromBatch?: boolean): unknown {
+		throw new Error('Not implemented');
+	}
+
 	abstract get(placeholderValues?: Record<string, unknown>): Result<T['type'], T['get']>;
 
+	mapGetResult(_result: unknown, _isFromBatch?: boolean): unknown {
+		throw new Error('Not implemented');
+	}
+
 	abstract values(placeholderValues?: Record<string, unknown>): Result<T['type'], T['values']>;
 
 	execute(placeholderValues?: Record<string, unknown>): ExecuteResult<T['type'], T['execute']> {
@@ -61,6 +79,20 @@ export abstract class PreparedQuery<T extends PreparedQueryConfig> {
 		}
 		return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues));
 	}
+
+	mapResult(response: unknown, isFromBatch?: boolean) {
+		switch (this.executeMethod) {
+			case 'run': {
+				return this.mapRunResult(response, isFromBatch);
+			}
+			case 'all': {
+				return this.mapAllResult(response, isFromBatch);
+			}
+			case 'get': {
+				return this.mapGetResult(response, isFromBatch);
+			}
+		}
+	}
 }
 
 export interface SQLiteTransactionConfig {
@@ -87,13 +119,13 @@ export abstract class SQLiteSession<
 		fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 		customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown,
-	): PreparedQuery<PreparedQueryConfig & { type: TResultKind }>;
+	): SQLitePreparedQuery<PreparedQueryConfig & { type: TResultKind }>;
 
 	prepareOneTimeQuery(
 		query: Query,
 		fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
-	): PreparedQuery<PreparedQueryConfig & { type: TResultKind }> {
+	): SQLitePreparedQuery<PreparedQueryConfig & { type: TResultKind }> {
 		return this.prepareQuery(query, fields, executeMethod);
 	}
 
@@ -105,54 +137,53 @@ export abstract class SQLiteSession<
 	run(query: SQL): Result<TResultKind, TRunResult> {
 		const staticQuery = this.dialect.sqlToQuery(query);
 		try {
-			return this.prepareOneTimeQuery(staticQuery, undefined, 'run').run();
+			return this.prepareOneTimeQuery(staticQuery, undefined, 'run').run() as Result<TResultKind, TRunResult>;
 		} catch (err) {
-			throw DrizzleError.wrap(err, `Failed to run the query '${staticQuery.sql}'`);
+			throw new DrizzleError({ cause: err, message: `Failed to run the query '${staticQuery.sql}'` });
 		}
 	}
 
+	/** @internal */
+	extractRawRunValueFromBatchResult(result: unknown) {
+		return result;
+	}
+
 	all<T = unknown>(query: SQL): Result<TResultKind, T[]> {
-		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run').all();
+		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run').all() as Result<TResultKind, T[]>;
+	}
+
+	/** @internal */
+	extractRawAllValueFromBatchResult(_result: unknown): unknown {
+		throw new Error('Not implemented');
 	}
 
 	get<T = unknown>(query: SQL): Result<TResultKind, T> {
-		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run').get();
+		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run').get() as Result<TResultKind, T>;
+	}
+
+	/** @internal */
+	extractRawGetValueFromBatchResult(_result: unknown): unknown {
+		throw new Error('Not implemented');
 	}
 
 	values<T extends any[] = unknown[]>(
 		query: SQL,
 	): Result<TResultKind, T[]> {
-		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run').values();
+		return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), undefined, 'run').values() as Result<
+			TResultKind,
+			T[]
+		>;
 	}
-}
 
-interface ResultHKT {
-	readonly $brand: 'SQLiteResultHKT';
-	readonly config: unknown;
-	readonly type: unknown;
-}
-
-interface SyncResultHKT extends ResultHKT {
-	readonly type: this['config'];
-}
-
-interface AsyncResultHKT extends ResultHKT {
-	readonly type: Promise<this['config']>;
-}
-
-interface DBAsyncResultHKT extends ResultHKT {
-	readonly type: SQLiteRaw<this['config']>;
+	/** @internal */
+	extractRawValuesValueFromBatchResult(_result: unknown): unknown {
+		throw new Error('Not implemented');
+	}
 }
 
-export type Result<TKind extends 'sync' | 'async', TResult> =
-	(('sync' extends TKind ? SyncResultHKT : AsyncResultHKT) & {
-		readonly config: TResult;
-	})['type'];
+export type Result<TKind extends 'sync' | 'async', TResult> = { sync: TResult; async: Promise<TResult> }[TKind];
 
-export type DBResult<TKind extends 'sync' | 'async', TResult> =
-	(('sync' extends TKind ? SyncResultHKT : DBAsyncResultHKT) & {
-		readonly config: TResult;
-	})['type'];
+export type DBResult<TKind extends 'sync' | 'async', TResult> = { sync: TResult; async: SQLiteRaw<TResult> }[TKind];
 
 export abstract class SQLiteTransaction<
 	TResultType extends 'sync' | 'async',
diff --git a/drizzle-orm/src/sqlite-proxy/session.ts b/drizzle-orm/src/sqlite-proxy/session.ts
index e9b09990b..6b0bef077 100644
--- a/drizzle-orm/src/sqlite-proxy/session.ts
+++ b/drizzle-orm/src/sqlite-proxy/session.ts
@@ -11,7 +11,7 @@ import type {
 	SQLiteExecuteMethod,
 	SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
-import { PreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
+import { SQLitePreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
 import { type RemoteCallback, type SqliteRemoteResult } from './driver.ts';
 
@@ -44,7 +44,7 @@ export class SQLiteRemoteSession<
 		fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 	): PreparedQuery<T> {
-		return new PreparedQuery(this.client, query.sql, query.params, this.logger, fields, executeMethod);
+		return new PreparedQuery(this.client, query, this.logger, fields, executeMethod);
 	}
 
 	override async transaction<T>(
@@ -94,28 +94,27 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 
 	constructor(
 		private client: RemoteCallback,
-		private queryString: string,
-		private params: unknown[],
+		query: Query,
 		private logger: Logger,
 		private fields: SelectedFieldsOrdered | undefined,
 		executeMethod: SQLiteExecuteMethod,
 	) {
-		super('async', executeMethod);
+		super('async', executeMethod, query);
 	}
 
 	run(placeholderValues?: Record<string, unknown>): Promise<SqliteRemoteResult> {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
-		return this.client(this.queryString, params, 'run');
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		return this.client(this.query.sql, params, 'run');
 	}
 
 	async all(placeholderValues?: Record<string, unknown>): Promise<T['all']> {
-		const { fields, queryString, logger, joinsNotNullableMap } = this;
+		const { fields, query, logger, joinsNotNullableMap } = this;
 
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		logger.logQuery(queryString, params);
+		const params = fillPlaceholders(query.params, placeholderValues ?? {});
+		logger.logQuery(query.sql, params);
 
-		const { rows } = await this.client(queryString, params, 'all');
+		const { rows } = await this.client(query.sql, params, 'all');
 
 		if (fields) {
 			return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
@@ -125,12 +124,12 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	async get(placeholderValues?: Record<string, unknown>): Promise<T['get']> {
-		const { fields, queryString, logger, joinsNotNullableMap } = this;
+		const { fields, query, logger, joinsNotNullableMap } = this;
 
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		logger.logQuery(queryString, params);
+		const params = fillPlaceholders(query.params, placeholderValues ?? {});
+		logger.logQuery(query.sql, params);
 
-		const clientResult = await this.client(queryString, params, 'get');
+		const clientResult = await this.client(query.sql, params, 'get');
 
 		if (fields) {
 			if (clientResult.rows === undefined) {
@@ -143,9 +142,9 @@ export class PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig>
 	}
 
 	async values<T extends any[] = unknown[]>(placeholderValues?: Record<string, unknown>): Promise<T[]> {
-		const params = fillPlaceholders(this.params, placeholderValues ?? {});
-		this.logger.logQuery(this.queryString, params);
-		const clientResult = await this.client(this.queryString, params, 'values');
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		const clientResult = await this.client(this.query.sql, params, 'values');
 		return clientResult.rows as T[];
 	}
 }
diff --git a/drizzle-orm/src/table.ts b/drizzle-orm/src/table.ts
index a6e6f0fc7..82e34f4e6 100644
--- a/drizzle-orm/src/table.ts
+++ b/drizzle-orm/src/table.ts
@@ -112,7 +112,24 @@ export function isTable(table: unknown): table is Table {
 	return typeof table === 'object' && table !== null && IsDrizzleTable in table;
 }
 
-export type AnyTable<TPartial extends Partial<TableConfig> = {}> = Table<UpdateTableConfig<TableConfig, TPartial>>;
+/**
+ * Any table with a specified boundary.
+ *
+ * @example
+	```ts
+	// Any table with a specific name
+	type AnyUsersTable = AnyTable<{ name: 'users' }>;
+	```
+ *
+ * To describe any table with any config, simply use `Table` without any type arguments, like this:
+ *
+	```ts
+	function needsTable(table: Table) {
+		...
+	}
+	```
+ */
+export type AnyTable<TPartial extends Partial<TableConfig>> = Table<UpdateTableConfig<TableConfig, TPartial>>;
 
 export function getTableName<T extends Table>(table: T): T['_']['name'] {
 	return table[TableName];
@@ -155,7 +172,7 @@ export type InferModelFromColumns<
 		}
 >;
 
-/** @deprecated Use one of the alternatives: {@link InferSelectModel} / {@link InferInsertModel}, or `table._.inferSelect` / `table._.inferInsert`
+/** @deprecated Use one of the alternatives: {@link InferSelectModel} / {@link InferInsertModel}, or `table.$inferSelect` / `table.$inferInsert`
  */
 export type InferModel<
 	TTable extends Table,
diff --git a/drizzle-orm/src/version.ts b/drizzle-orm/src/version.ts
index 355672c5f..020f2172c 100644
--- a/drizzle-orm/src/version.ts
+++ b/drizzle-orm/src/version.ts
@@ -1,3 +1,3 @@
-// @ts-expect-error - imported using Rollup json plugin
+// @ts-ignore - imported using Rollup json plugin
 export { version as npmVersion } from '../package.json';
 export const compatibilityVersion = 5;
diff --git a/drizzle-orm/tests/tsconfig.json b/drizzle-orm/tests/tsconfig.json
index d3e519834..851b0a8fd 100644
--- a/drizzle-orm/tests/tsconfig.json
+++ b/drizzle-orm/tests/tsconfig.json
@@ -1,11 +1,7 @@
 {
 	"extends": "../tsconfig.build.json",
 	"compilerOptions": {
-		"module": "esnext",
-		"target": "esnext",
-		"noEmit": true,
-		"rootDir": "..",
-		"outDir": "./.cache"
+		"rootDir": ".."
 	},
 	"include": [".", "../src"]
 }
diff --git a/drizzle-orm/tsconfig.build.json b/drizzle-orm/tsconfig.build.json
index f8c8deaeb..1fb3006cb 100644
--- a/drizzle-orm/tsconfig.build.json
+++ b/drizzle-orm/tsconfig.build.json
@@ -4,8 +4,6 @@
 		"composite": true,
 		"baseUrl": ".",
 		"verbatimModuleSyntax": true,
-		"moduleResolution": "NodeNext",
-		"allowImportingTsExtensions": true,
 		"noEmit": true,
 		"incremental": true,
 		"paths": {
diff --git a/drizzle-orm/tsconfig.cjs.json b/drizzle-orm/tsconfig.cjs.json
index fa57f71e1..4554c9386 100644
--- a/drizzle-orm/tsconfig.cjs.json
+++ b/drizzle-orm/tsconfig.cjs.json
@@ -1,8 +1,6 @@
 {
 	"extends": "./tsconfig.build.json",
 	"compilerOptions": {
-		"target": "es2020",
-		"module": "es2020",
 		"rootDir": "src"
 	}
 }
diff --git a/drizzle-orm/type-tests/mysql/delete.ts b/drizzle-orm/type-tests/mysql/delete.ts
index 0842ae963..314fd2ed5 100644
--- a/drizzle-orm/type-tests/mysql/delete.ts
+++ b/drizzle-orm/type-tests/mysql/delete.ts
@@ -1,7 +1,9 @@
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
+import type { MySqlDelete } from '~/mysql-core/index.ts';
 import type { MySqlRawQueryResult } from '~/mysql2/index.ts';
+import { sql } from '~/sql/index.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
@@ -32,3 +34,28 @@ Expect<Equal<MySqlRawQueryResult, typeof deleteReturningPartial>>;
 const deleteReturningPartialStmt = db.delete(users).prepare();
 const deleteReturningPartialPrepared = await deleteReturningPartialStmt.execute();
 Expect<Equal<MySqlRawQueryResult, typeof deleteReturningPartialPrepared>>;
+
+{
+	function dynamic<T extends MySqlDelete>(qb: T) {
+		return qb.where(sql``);
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<MySqlRawQueryResult, typeof result>>;
+}
+
+{
+	db
+		.delete(users)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.delete(users)
+		.$dynamic()
+		.where(sql``)
+		.where(sql``);
+}
diff --git a/drizzle-orm/type-tests/mysql/insert.ts b/drizzle-orm/type-tests/mysql/insert.ts
index ab5cb5ee4..c5d9814ab 100644
--- a/drizzle-orm/type-tests/mysql/insert.ts
+++ b/drizzle-orm/type-tests/mysql/insert.ts
@@ -1,6 +1,6 @@
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
-import { int, mysqlTable, text } from '~/mysql-core/index.ts';
+import { int, type MySqlInsert, mysqlTable, text } from '~/mysql-core/index.ts';
 import type { MySqlRawQueryResult } from '~/mysql2/index.ts';
 import { sql } from '~/sql/index.ts';
 import { db } from './db.ts';
@@ -101,3 +101,23 @@ Expect<Equal<MySqlRawQueryResult, typeof insertReturningSqlPrepared>>;
 
 	await db.insert(users).values({ name: 'John Wick', age: 58, occupation: 'housekeeper' });
 }
+
+{
+	function dynamic<T extends MySqlInsert>(qb: T) {
+		return qb.onDuplicateKeyUpdate({ set: {} });
+	}
+
+	const qbBase = db.insert(users).values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0 }).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<MySqlRawQueryResult, typeof result>>;
+}
+
+{
+	db
+		.insert(users)
+		.values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0 })
+		.onDuplicateKeyUpdate({ set: {} })
+		// @ts-expect-error method was already called
+		.onDuplicateKeyUpdate({ set: {} });
+}
diff --git a/drizzle-orm/type-tests/mysql/select.ts b/drizzle-orm/type-tests/mysql/select.ts
index 17c9d12b3..fd28ce598 100644
--- a/drizzle-orm/type-tests/mysql/select.ts
+++ b/drizzle-orm/type-tests/mysql/select.ts
@@ -26,6 +26,7 @@ import { param, sql } from '~/sql/index.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
+import { type MySqlSelect, type MySqlSelectQueryBuilder, QueryBuilder } from '~/mysql-core/index.ts';
 import { db } from './db.ts';
 import { cities, classes, newYorkers, users } from './tables.ts';
 
@@ -433,3 +434,173 @@ await db
 		Expect<Equal<typeof users.$inferSelect, typeof row>>();
 	}
 }
+
+{
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		.limit(10)
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+}
+
+{
+	function withFriends<T extends MySqlSelect>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function withFriends<T extends MySqlSelectQueryBuilder>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function dynamic<T extends MySqlSelect>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	// TODO: add to docs
+	function dynamic<T extends MySqlSelectQueryBuilder>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
+	}
+
+	const query = new QueryBuilder().select().from(users).$dynamic();
+	dynamic(query);
+}
+
+{
+	// TODO: add to docs
+	function paginated<T extends MySqlSelect>(qb: T, page: number) {
+		return qb.limit(10).offset((page - 1) * 10);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await paginated(qb, 1);
+
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	db
+		.select()
+		.from(users)
+		.where(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.select()
+		.from(users)
+		.having(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.having(sql``);
+
+	db
+		.select()
+		.from(users)
+		.groupBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.groupBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.orderBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.orderBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.limit(10)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.limit(10);
+
+	db
+		.select()
+		.from(users)
+		.offset(10)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.offset(10);
+
+	db
+		.select()
+		.from(users)
+		.for('update')
+		.limit(10)
+		// @ts-expect-error method was already called
+		.for('update');
+}
diff --git a/drizzle-orm/type-tests/mysql/update.ts b/drizzle-orm/type-tests/mysql/update.ts
new file mode 100644
index 000000000..31139ee7a
--- /dev/null
+++ b/drizzle-orm/type-tests/mysql/update.ts
@@ -0,0 +1,26 @@
+import { type Equal, Expect } from 'type-tests/utils.ts';
+import type { MySqlUpdate } from '~/mysql-core/index.ts';
+import type { MySqlRawQueryResult } from '~/mysql2/session.ts';
+import { sql } from '~/sql/index.ts';
+import { db } from './db.ts';
+import { users } from './tables.ts';
+
+{
+	function dynamic<T extends MySqlUpdate>(qb: T) {
+		return qb.where(sql``);
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<MySqlRawQueryResult, typeof result>>;
+}
+
+{
+	db
+		.update(users)
+		.set({})
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+}
diff --git a/drizzle-orm/type-tests/pg/delete.ts b/drizzle-orm/type-tests/pg/delete.ts
index 66eddc0c3..7fd9c3dc6 100644
--- a/drizzle-orm/type-tests/pg/delete.ts
+++ b/drizzle-orm/type-tests/pg/delete.ts
@@ -2,6 +2,8 @@ import type { QueryResult } from 'pg';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
+import type { PgDelete } from '~/pg-core/index.ts';
+import { sql } from '~/sql/index.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
@@ -38,3 +40,39 @@ const deleteReturningPartialStmt = db.delete(users).returning({
 }).prepare('deleteReturningPartialStmt');
 const deleteReturningPartialPrepared = await deleteReturningPartialStmt.execute();
 Expect<Equal<{ myId: number; myHomeCity: number }[], typeof deleteReturningPartialPrepared>>;
+
+{
+	function dynamic<T extends PgDelete>(qb: T) {
+		return qb.where(sql``).returning();
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends PgDelete>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.delete(users)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.delete(users)
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+}
diff --git a/drizzle-orm/type-tests/pg/insert.ts b/drizzle-orm/type-tests/pg/insert.ts
index d076d4dac..1ea9e8bd4 100644
--- a/drizzle-orm/type-tests/pg/insert.ts
+++ b/drizzle-orm/type-tests/pg/insert.ts
@@ -1,6 +1,7 @@
 import type { QueryResult } from 'pg';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
+import type { PgInsert } from '~/pg-core/query-builders/insert.ts';
 import { sql } from '~/sql/index.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
@@ -172,3 +173,34 @@ Expect<
 		classLower: string;
 	}[], typeof insertReturningSqlPrepared>
 >;
+
+{
+	function dynamic<T extends PgInsert>(qb: T) {
+		return qb.returning().onConflictDoNothing().onConflictDoUpdate({ set: {}, target: users.id, where: sql`` });
+	}
+
+	const qbBase = db.insert(users).values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, arrayCol: [] }).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends PgInsert>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.insert(users).values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, arrayCol: [] }).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.insert(users)
+		.values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, arrayCol: [] })
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+}
diff --git a/drizzle-orm/type-tests/pg/select.ts b/drizzle-orm/type-tests/pg/select.ts
index f3fb131ba..9f22782f8 100644
--- a/drizzle-orm/type-tests/pg/select.ts
+++ b/drizzle-orm/type-tests/pg/select.ts
@@ -28,8 +28,15 @@ import {
 	or,
 } from '~/expressions.ts';
 import { alias } from '~/pg-core/alias.ts';
-import { boolean, integer, pgTable, text } from '~/pg-core/index.ts';
-import type { AnyPgSelect } from '~/pg-core/query-builders/select.types.ts';
+import {
+	boolean,
+	integer,
+	type PgSelect,
+	type PgSelectQueryBuilder,
+	pgTable,
+	QueryBuilder,
+	text,
+} from '~/pg-core/index.ts';
 import { type SQL, sql } from '~/sql/index.ts';
 
 import { db } from './db.ts';
@@ -857,10 +864,26 @@ Expect<
 await db
 	.select()
 	.from(users)
-	.for('update')
-	.for('no key update', { of: users })
-	.for('no key update', { of: users, skipLocked: true })
-	.for('share', { of: users, noWait: true })
+	.for('update');
+
+await db
+	.select()
+	.from(users)
+	.for('no key update', { of: users });
+
+await db
+	.select()
+	.from(users)
+	.for('no key update', { of: users, skipLocked: true });
+
+await db
+	.select()
+	.from(users)
+	.for('share', { of: users, noWait: true });
+
+await db
+	.select()
+	.from(users)
 	// @ts-expect-error - can't use both skipLocked and noWait
 	.for('share', { of: users, noWait: true, skipLocked: true });
 
@@ -926,14 +949,174 @@ await db
 	>;
 }
 
+{
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		.limit(10)
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+}
+
+{
+	function withFriends<T extends PgSelect>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function withFriends<T extends PgSelectQueryBuilder>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function dynamic<T extends PgSelect>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
 {
 	// TODO: add to docs
-	const withPagination = <T extends AnyPgSelect>(qb: T) => {
-		return qb.offset(10).limit(10);
-	};
+	function dynamic<T extends PgSelectQueryBuilder>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1).for('update');
+	}
+
+	const query = new QueryBuilder().select().from(users).$dynamic();
+	dynamic(query);
+}
+
+{
+	// TODO: add to docs
+	function paginated<T extends PgSelect>(qb: T, page: number) {
+		return qb.limit(10).offset((page - 1) * 10);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await paginated(qb, 1);
 
-	const qb = db.select().from(users);
-	await withPagination(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	db
+		.select()
+		.from(users)
+		.where(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.select()
+		.from(users)
+		.having(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.having(sql``);
+
+	db
+		.select()
+		.from(users)
+		.groupBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.groupBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.orderBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.orderBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.limit(10)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.limit(10);
+
+	db
+		.select()
+		.from(users)
+		.offset(10)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.offset(10);
+
+	db
+		.select()
+		.from(users)
+		.for('update')
+		.limit(10)
+		// @ts-expect-error method was already called
+		.for('update');
 }
 
 {
diff --git a/drizzle-orm/type-tests/pg/update.ts b/drizzle-orm/type-tests/pg/update.ts
index 4123b26fe..187afa147 100644
--- a/drizzle-orm/type-tests/pg/update.ts
+++ b/drizzle-orm/type-tests/pg/update.ts
@@ -2,6 +2,8 @@ import type { QueryResult } from 'pg';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
+import type { PgUpdate } from '~/pg-core/index.ts';
+import { sql } from '~/sql/index.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
@@ -46,3 +48,41 @@ const updateReturningStmt = db.update(users)
 	.prepare('updateReturningStmt');
 const updateReturningPrepared = await updateReturningStmt.execute();
 Expect<Equal<{ text: string | null }[], typeof updateReturningPrepared>>;
+
+{
+	function dynamic<T extends PgUpdate>(qb: T) {
+		return qb.where(sql``).returning();
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends PgUpdate>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.update(users)
+		.set({})
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+
+	db
+		.update(users)
+		.set({})
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+}
diff --git a/drizzle-orm/type-tests/sqlite/delete.ts b/drizzle-orm/type-tests/sqlite/delete.ts
index 10827099f..f35581233 100644
--- a/drizzle-orm/type-tests/sqlite/delete.ts
+++ b/drizzle-orm/type-tests/sqlite/delete.ts
@@ -3,6 +3,8 @@ import { eq } from '~/expressions.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
+import { sql } from '~/sql/index.ts';
+import type { SQLiteDelete } from '~/sqlite-core/index.ts';
 import { type DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
 import { users } from './tables.ts';
@@ -114,3 +116,39 @@ const deleteValuesBunReturningPartial = bunDb.delete(users).returning({
 	myHomeCity: users.homeCity,
 }).values();
 Expect<Equal<any[][], typeof deleteValuesBunReturningPartial>>;
+
+{
+	function dynamic<T extends SQLiteDelete>(qb: T) {
+		return qb.where(sql``).returning();
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends SQLiteDelete>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.delete(users).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.delete(users)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.delete(users)
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+}
diff --git a/drizzle-orm/type-tests/sqlite/insert.ts b/drizzle-orm/type-tests/sqlite/insert.ts
index cc877686c..185c937eb 100644
--- a/drizzle-orm/type-tests/sqlite/insert.ts
+++ b/drizzle-orm/type-tests/sqlite/insert.ts
@@ -3,6 +3,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/expressions.ts';
 import { sql } from '~/sql/index.ts';
+import type { SQLiteInsert } from '~/sqlite-core/query-builders/insert.ts';
 import { type DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
 import type { NewUser } from './tables.ts';
@@ -171,3 +172,36 @@ const stmt = db.select().from(users)
 	.limit(sql.placeholder('limit'))
 	.prepare();
 stmt.run({ id: 1, limit: 10, offset: 20 });
+
+{
+	function dynamic<T extends SQLiteInsert>(qb: T) {
+		return qb.returning().onConflictDoNothing().onConflictDoUpdate({ set: {}, target: users.id, where: sql`` });
+	}
+
+	const qbBase = db.insert(users).values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, serialNotNull: 0 })
+		.$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends SQLiteInsert>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.insert(users).values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, serialNotNull: 0 })
+		.$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.insert(users)
+		.values({ age1: 0, class: 'A', enumCol: 'a', homeCity: 0, serialNotNull: 0 })
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+}
diff --git a/drizzle-orm/type-tests/sqlite/select.ts b/drizzle-orm/type-tests/sqlite/select.ts
index ad9ef2cf2..6693b8e25 100644
--- a/drizzle-orm/type-tests/sqlite/select.ts
+++ b/drizzle-orm/type-tests/sqlite/select.ts
@@ -26,6 +26,7 @@ import { alias } from '~/sqlite-core/alias.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
+import type { SQLiteSelect, SQLiteSelectQueryBuilder } from '~/sqlite-core/query-builders/select.types.ts';
 import { db } from './db.ts';
 import { cities, classes, newYorkers, users } from './tables.ts';
 
@@ -438,3 +439,143 @@ Expect<
 		>
 	>;
 }
+
+{
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+
+	db
+		.select()
+		.from(users)
+		.where(eq(users.id, 1))
+		.limit(10)
+		// @ts-expect-error - can't use where twice
+		.where(eq(users.id, 1));
+}
+
+{
+	function withFriends<T extends SQLiteSelect>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function withFriends<T extends SQLiteSelectQueryBuilder>(qb: T) {
+		const friends = alias(users, 'friends');
+		const friends2 = alias(users, 'friends2');
+		const friends3 = alias(users, 'friends3');
+		const friends4 = alias(users, 'friends4');
+		const friends5 = alias(users, 'friends5');
+		return qb
+			.leftJoin(friends, sql`true`)
+			.leftJoin(friends2, sql`true`)
+			.leftJoin(friends3, sql`true`)
+			.leftJoin(friends4, sql`true`)
+			.leftJoin(friends5, sql`true`);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await withFriends(qb);
+	Expect<
+		Equal<typeof result, {
+			users_table: typeof users.$inferSelect;
+			friends: typeof users.$inferSelect | null;
+			friends2: typeof users.$inferSelect | null;
+			friends3: typeof users.$inferSelect | null;
+			friends4: typeof users.$inferSelect | null;
+			friends5: typeof users.$inferSelect | null;
+		}[]>
+	>;
+}
+
+{
+	function dynamic<T extends SQLiteSelect>(qb: T) {
+		return qb.where(sql``).having(sql``).groupBy(sql``).orderBy(sql``).limit(1).offset(1);
+	}
+
+	const qb = db.select().from(users).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+{
+	db
+		.select()
+		.from(users)
+		.where(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.where(sql``);
+
+	db
+		.select()
+		.from(users)
+		.having(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.having(sql``);
+
+	db
+		.select()
+		.from(users)
+		.groupBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.groupBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.orderBy(sql``)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.orderBy(sql``);
+
+	db
+		.select()
+		.from(users)
+		.limit(10)
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.limit(10);
+
+	db
+		.select()
+		.from(users)
+		.offset(10)
+		.limit(10)
+		// @ts-expect-error method was already called
+		.offset(10);
+}
diff --git a/drizzle-orm/type-tests/sqlite/update.ts b/drizzle-orm/type-tests/sqlite/update.ts
index bde8bfbcb..0fd25bd6c 100644
--- a/drizzle-orm/type-tests/sqlite/update.ts
+++ b/drizzle-orm/type-tests/sqlite/update.ts
@@ -2,6 +2,8 @@ import type { RunResult } from 'better-sqlite3';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
+import { sql } from '~/sql/index.ts';
+import type { SQLiteUpdate } from '~/sqlite-core/query-builders/update.ts';
 import { type DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
 import { users } from './tables.ts';
@@ -93,3 +95,41 @@ const updateGetReturningAllBun = bunDb.update(users)
 	.returning()
 	.get();
 Expect<Equal<typeof users.$inferSelect, typeof updateGetReturningAllBun>>;
+
+{
+	function dynamic<T extends SQLiteUpdate>(qb: T) {
+		return qb.where(sql``).returning();
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = dynamic(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	function withReturning<T extends SQLiteUpdate>(qb: T) {
+		return qb.returning();
+	}
+
+	const qbBase = db.update(users).set({}).$dynamic();
+	const qb = withReturning(qbBase);
+	const result = await qb;
+	Expect<Equal<typeof users.$inferSelect[], typeof result>>;
+}
+
+{
+	db
+		.update(users)
+		.set({})
+		.returning()
+		// @ts-expect-error method was already called
+		.returning();
+
+	db
+		.update(users)
+		.set({})
+		.where(sql``)
+		// @ts-expect-error method was already called
+		.where(sql``);
+}
diff --git a/drizzle-orm/type-tests/tsconfig.json b/drizzle-orm/type-tests/tsconfig.json
index 449ace992..b4e6c8007 100644
--- a/drizzle-orm/type-tests/tsconfig.json
+++ b/drizzle-orm/type-tests/tsconfig.json
@@ -2,11 +2,10 @@
 	"extends": "../tsconfig.build.json",
 	"compilerOptions": {
 		"composite": false,
-		"module": "esnext",
-		"target": "esnext",
 		"noEmit": true,
 		"rootDir": "..",
 		"outDir": "./.cache"
 	},
-	"include": [".", "../src"]
+	"include": [".", "../src"],
+	"exclude": ["**/playground"]
 }
diff --git a/integration-tests/tests/awsdatapi.test.ts b/integration-tests/tests/awsdatapi.test.ts
index 8524cbae1..1f390eb70 100644
--- a/integration-tests/tests/awsdatapi.test.ts
+++ b/integration-tests/tests/awsdatapi.test.ts
@@ -766,7 +766,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -825,7 +825,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);
diff --git a/integration-tests/tests/better-sqlite.test.ts b/integration-tests/tests/better-sqlite.test.ts
index 3b7e4e277..44e04858b 100644
--- a/integration-tests/tests/better-sqlite.test.ts
+++ b/integration-tests/tests/better-sqlite.test.ts
@@ -1541,7 +1541,7 @@ test.serial('transaction rollback', (t) => {
 		db.transaction((tx) => {
 			tx.insert(users).values({ balance: 100 }).run();
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = db.select().from(users).all();
 
@@ -1600,7 +1600,7 @@ test.serial('nested transaction rollback', (t) => {
 			tx.transaction((tx) => {
 				tx.update(users).set({ balance: 200 }).run();
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = db.select().from(users).all();
@@ -1846,16 +1846,16 @@ test.serial('insert with onConflict do update where', (t) => {
 
 	db
 		.insert(usersTable)
-		.values([{ id: 1, name: "John", verified: false }])
+		.values([{ id: 1, name: 'John', verified: false }])
 		.run();
 
 	db
 		.insert(usersTable)
-		.values({ id: 1, name: "John1", verified: true })
+		.values({ id: 1, name: 'John1', verified: true })
 		.onConflictDoUpdate({
 			target: usersTable.id,
-			set: { name: "John1", verified: true },
-			where: eq(usersTable.verified, false)
+			set: { name: 'John1', verified: true },
+			where: eq(usersTable.verified, false),
 		})
 		.run();
 
@@ -1865,8 +1865,8 @@ test.serial('insert with onConflict do update where', (t) => {
 		.where(eq(usersTable.id, 1))
 		.all();
 
-	t.deepEqual(res, [{ id: 1, name: "John1", verified: true }]);
-})
+	t.deepEqual(res, [{ id: 1, name: 'John1', verified: true }]);
+});
 
 test.serial('insert undefined', (t) => {
 	const { db } = t.context;
diff --git a/integration-tests/tests/d1.test.ts b/integration-tests/tests/d1.test.ts
index 05d490e11..04092ced5 100644
--- a/integration-tests/tests/d1.test.ts
+++ b/integration-tests/tests/d1.test.ts
@@ -1424,7 +1424,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 }).run();
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users).all();
 
@@ -1483,7 +1483,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 }).run();
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users).all();
@@ -1669,16 +1669,16 @@ test.serial('insert with onConflict do update where', async (t) => {
 
 	await db
 		.insert(usersTable)
-		.values([{ id: 1, name: "John", verified: 0 }])
+		.values([{ id: 1, name: 'John', verified: 0 }])
 		.run();
 
 	await db
 		.insert(usersTable)
-		.values({ id: 1, name: "John1", verified: 0 })
+		.values({ id: 1, name: 'John1', verified: 0 })
 		.onConflictDoUpdate({
 			target: usersTable.id,
-			set: { name: "John1", verified: 1 },
-			where: eq(usersTable.verified, 0)
+			set: { name: 'John1', verified: 1 },
+			where: eq(usersTable.verified, 0),
 		})
 		.run();
 
@@ -1688,8 +1688,8 @@ test.serial('insert with onConflict do update where', async (t) => {
 		.where(eq(usersTable.id, 1))
 		.all();
 
-	t.deepEqual(res, [{ id: 1, name: "John1", verified: 1 }]);
-})
+	t.deepEqual(res, [{ id: 1, name: 'John1', verified: 1 }]);
+});
 
 test.serial('insert undefined', async (t) => {
 	const { db } = t.context;
diff --git a/integration-tests/tests/libsql-batch.test.ts b/integration-tests/tests/libsql-batch.test.ts
index 292648d02..fd9c61bbd 100644
--- a/integration-tests/tests/libsql-batch.test.ts
+++ b/integration-tests/tests/libsql-batch.test.ts
@@ -407,7 +407,10 @@ test('insert + db.all + db.get + db.values + db.run', async () => {
 		{ id: 2, name: 'Dan', verified: 0, invited_by: null },
 	]);
 
-	expect(batchResponse[3]).toEqual([[1, 'John', 0, null], [2, 'Dan', 0, null]]);
+	expect(batchResponse[3].map((row) => Array.prototype.slice.call(row))).toEqual([
+		[1, 'John', 0, null],
+		[2, 'Dan', 0, null],
+	]);
 
 	expect(batchResponse[4]).toEqual(
 		{ id: 1, name: 'John', verified: 0, invited_by: null },
diff --git a/integration-tests/tests/libsql.test.ts b/integration-tests/tests/libsql.test.ts
index 575f20c75..fc75bf059 100644
--- a/integration-tests/tests/libsql.test.ts
+++ b/integration-tests/tests/libsql.test.ts
@@ -1471,7 +1471,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 }).run();
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users).all();
 
@@ -1530,7 +1530,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 }).run();
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users).all();
@@ -1756,16 +1756,16 @@ test.serial('insert with onConflict do update where', async (t) => {
 
 	await db
 		.insert(usersTable)
-		.values([{ id: 1, name: "John", verified: false }])
+		.values([{ id: 1, name: 'John', verified: false }])
 		.run();
 
 	await db
 		.insert(usersTable)
-		.values({ id: 1, name: "John1", verified: true })
+		.values({ id: 1, name: 'John1', verified: true })
 		.onConflictDoUpdate({
 			target: usersTable.id,
-			set: { name: "John1", verified: true },
-			where: eq(usersTable.verified, false)
+			set: { name: 'John1', verified: true },
+			where: eq(usersTable.verified, false),
 		})
 		.run();
 
@@ -1775,8 +1775,8 @@ test.serial('insert with onConflict do update where', async (t) => {
 		.where(eq(usersTable.id, 1))
 		.all();
 
-	t.deepEqual(res, [{ id: 1, name: "John1", verified: true }]);
-})
+	t.deepEqual(res, [{ id: 1, name: 'John1', verified: true }]);
+});
 
 test.serial('insert with onConflict do update using composite pk', async (t) => {
 	const { db } = t.context;
diff --git a/integration-tests/tests/mysql.prefixed.test.ts b/integration-tests/tests/mysql.prefixed.test.ts
index e042dd73b..c4b4d25f7 100644
--- a/integration-tests/tests/mysql.prefixed.test.ts
+++ b/integration-tests/tests/mysql.prefixed.test.ts
@@ -1484,7 +1484,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -1543,7 +1543,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index 3f05ffe25..89414a464 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -1673,7 +1673,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -1732,7 +1732,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);
diff --git a/integration-tests/tests/neon-http.test.ts b/integration-tests/tests/neon-http.test.ts
index 83f0f8e17..5112fd3b1 100644
--- a/integration-tests/tests/neon-http.test.ts
+++ b/integration-tests/tests/neon-http.test.ts
@@ -6,6 +6,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	eq,
 	gt,
@@ -18,9 +21,6 @@ import {
 	sql,
 	type SQLWrapper,
 	TransactionRollbackError,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
 import { drizzle, type NeonHttpDatabase } from 'drizzle-orm/neon-http';
 import { migrate } from 'drizzle-orm/neon-http/migrator';
@@ -1426,20 +1426,71 @@ test.serial('array types', async (t) => {
 test.serial('select for ...', (t) => {
 	const { db } = t.context;
 
-	const query = db
-		.select()
-		.from(users2Table)
-		.for('update')
-		.for('no key update', { of: users2Table })
-		.for('no key update', { of: users2Table, skipLocked: true })
-		.for('share', { of: users2Table, noWait: true })
-		.toSQL();
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update')
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update$/,
+		);
+	}
 
-	t.regex(
-		query.sql,
-		// eslint-disable-next-line unicorn/better-regex
-		/ for update for no key update of "users2" for no key update of "users2" skip locked for share of "users2" no wait$/,
-	);
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update', { of: [users2Table, coursesTable] })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update of "users2", "courses"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/for no key update of "users2"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table, skipLocked: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for no key update of "users2" skip locked$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('share', { of: users2Table, noWait: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			// eslint-disable-next-line unicorn/better-regex
+			/for share of "users2" no wait$/,
+		);
+	}
 });
 
 test.serial('having', async (t) => {
@@ -2019,7 +2070,7 @@ test.serial.skip('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -2082,7 +2133,7 @@ test.serial.skip('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);
@@ -2323,7 +2374,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2333,17 +2384,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2355,11 +2406,11 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index fb2f058f6..f2a22a17e 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -5,6 +5,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	eq,
 	gt,
@@ -17,9 +20,6 @@ import {
 	sql,
 	type SQLWrapper,
 	TransactionRollbackError,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
 import { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
@@ -1576,20 +1576,71 @@ test.serial('array types', async (t) => {
 test.serial('select for ...', (t) => {
 	const { db } = t.context;
 
-	const query = db
-		.select()
-		.from(users2Table)
-		.for('update')
-		.for('no key update', { of: users2Table })
-		.for('no key update', { of: users2Table, skipLocked: true })
-		.for('share', { of: users2Table, noWait: true })
-		.toSQL();
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update')
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update$/,
+		);
+	}
 
-	t.regex(
-		query.sql,
-		// eslint-disable-next-line unicorn/better-regex
-		/ for update for no key update of "users2" for no key update of "users2" skip locked for share of "users2" no wait$/,
-	);
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update', { of: [users2Table, coursesTable] })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update of "users2", "courses"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/for no key update of "users2"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table, skipLocked: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for no key update of "users2" skip locked$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('share', { of: users2Table, noWait: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			// eslint-disable-next-line unicorn/better-regex
+			/for share of "users2" no wait$/,
+		);
+	}
 });
 
 test.serial('having', async (t) => {
@@ -2165,7 +2216,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -2224,7 +2275,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);
@@ -2465,7 +2516,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2475,17 +2526,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2497,11 +2548,11 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });
diff --git a/integration-tests/tests/planetscale-serverless/mysql.test.ts b/integration-tests/tests/planetscale-serverless/mysql.test.ts
index 0006eed77..3d5ddafec 100644
--- a/integration-tests/tests/planetscale-serverless/mysql.test.ts
+++ b/integration-tests/tests/planetscale-serverless/mysql.test.ts
@@ -775,7 +775,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -834,7 +834,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);
diff --git a/integration-tests/tests/postgres.js.test.ts b/integration-tests/tests/postgres.js.test.ts
index 4659f7221..e95cc736d 100644
--- a/integration-tests/tests/postgres.js.test.ts
+++ b/integration-tests/tests/postgres.js.test.ts
@@ -5,6 +5,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	DrizzleError,
 	eq,
@@ -18,9 +21,6 @@ import {
 	type SQL,
 	sql,
 	type SQLWrapper,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
 import {
 	alias,
@@ -1307,20 +1307,71 @@ test.serial('select count w/ custom mapper', async (t) => {
 test.serial('select for ...', (t) => {
 	const { db } = t.context;
 
-	const query = db
-		.select()
-		.from(users2Table)
-		.for('update')
-		.for('no key update', { of: users2Table })
-		.for('no key update', { of: users2Table, skipLocked: true })
-		.for('share', { of: users2Table, noWait: true })
-		.toSQL();
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update')
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update$/,
+		);
+	}
 
-	t.regex(
-		query.sql,
-		// eslint-disable-next-line unicorn/better-regex
-		/select ("(id|name|city_id)"(, )?){3} from "users2" for update for no key update of "users2" for no key update of "users2" skip locked for share of "users2" no wait/,
-	);
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update', { of: [users2Table, coursesTable] })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update of "users2", "courses"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/for no key update of "users2"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table, skipLocked: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for no key update of "users2" skip locked$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('share', { of: users2Table, noWait: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			// eslint-disable-next-line unicorn/better-regex
+			/for share of "users2" no wait$/,
+		);
+	}
 });
 
 test.serial('having', async (t) => {
@@ -1854,7 +1905,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			await tx.rollback();
-		}), new DrizzleError('Rollback'));
+		}), new DrizzleError({ message: 'Rollback' }));
 
 	const result = await db.select().from(users);
 
@@ -1913,7 +1964,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				await tx.rollback();
-			}), new DrizzleError('Rollback'));
+			}), new DrizzleError({ message: 'Rollback' }));
 	});
 
 	const result = await db.select().from(users);
@@ -2071,7 +2122,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2081,17 +2132,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2103,11 +2154,11 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });
diff --git a/integration-tests/tests/sql.js.test.ts b/integration-tests/tests/sql.js.test.ts
index 38d638fe1..7e4df8036 100644
--- a/integration-tests/tests/sql.js.test.ts
+++ b/integration-tests/tests/sql.js.test.ts
@@ -1341,7 +1341,7 @@ test.serial('transaction rollback', (t) => {
 		db.transaction((tx) => {
 			tx.insert(users).values({ balance: 100 }).run();
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = db.select().from(users).all();
 
@@ -1400,7 +1400,7 @@ test.serial('nested transaction rollback', (t) => {
 			tx.transaction((tx) => {
 				tx.update(users).set({ balance: 200 }).run();
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = db.select().from(users).all();
diff --git a/integration-tests/tests/vercel-pg.test.ts b/integration-tests/tests/vercel-pg.test.ts
index 8a7eb47c3..c51f2bd62 100644
--- a/integration-tests/tests/vercel-pg.test.ts
+++ b/integration-tests/tests/vercel-pg.test.ts
@@ -6,6 +6,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	eq,
 	gt,
@@ -18,9 +21,6 @@ import {
 	sql,
 	type SQLWrapper,
 	TransactionRollbackError,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
 import {
 	alias,
@@ -1412,20 +1412,71 @@ test.serial('array types', async (t) => {
 test.serial('select for ...', (t) => {
 	const { db } = t.context;
 
-	const query = db
-		.select()
-		.from(users2Table)
-		.for('update')
-		.for('no key update', { of: users2Table })
-		.for('no key update', { of: users2Table, skipLocked: true })
-		.for('share', { of: users2Table, noWait: true })
-		.toSQL();
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update')
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update$/,
+		);
+	}
 
-	t.regex(
-		query.sql,
-		// eslint-disable-next-line unicorn/better-regex
-		/ for update for no key update of "users2" for no key update of "users2" skip locked for share of "users2" no wait$/,
-	);
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update', { of: [users2Table, coursesTable] })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update of "users2", "courses"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/for no key update of "users2"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table, skipLocked: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for no key update of "users2" skip locked$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('share', { of: users2Table, noWait: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			// eslint-disable-next-line unicorn/better-regex
+			/for share of "users2" no wait$/,
+		);
+	}
 });
 
 test.serial('having', async (t) => {
@@ -2001,7 +2052,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			tx.rollback();
-		}), new TransactionRollbackError());
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -2060,7 +2111,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				tx.rollback();
-			}), new TransactionRollbackError());
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);
@@ -2301,7 +2352,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2311,17 +2362,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2333,11 +2384,11 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });
diff --git a/integration-tests/tsconfig.json b/integration-tests/tsconfig.json
index 72238c14f..a80bcaf56 100644
--- a/integration-tests/tsconfig.json
+++ b/integration-tests/tsconfig.json
@@ -1,14 +1,11 @@
 {
 	"extends": "../tsconfig.json",
 	"compilerOptions": {
-		"module": "esnext",
-		"target": "esnext",
-		"moduleResolution": "NodeNext",
-		"allowImportingTsExtensions": true,
 		"noEmit": true,
 		"paths": {
 			"~/*": ["./tests/*"]
 		}
 	},
-	"include": ["tests", "type-tests"]
+	"include": ["tests", "type-tests"],
+	"exclude": ["**/playground"]
 }
diff --git a/output.txt b/output.txt
new file mode 100644
index 000000000..fbafeba84
--- /dev/null
+++ b/output.txt
@@ -0,0 +1,62 @@
+
+> @ b /home/dan/dev/drizzle-orm
+> pnpm build
+
+
+> @ build /home/dan/dev/drizzle-orm
+> turbo run build test:types //#lint --color
+
+• Packages in scope: //, drizzle-orm, drizzle-typebox, drizzle-valibot, drizzle-zod, integration-tests
+• Running build, test:types, //#lint in 6 packages
+• Remote caching disabled
+//:lint: cache miss, executing 7f90a6b29f6344d4
+drizzle-orm:test:types: cache miss, executing 8ccd4eb5348eda9b
+drizzle-orm:build: cache miss, executing c099f6c3096b9a29
+drizzle-orm:test:types: 
+drizzle-orm:test:types: > drizzle-orm@0.28.7 test:types /home/dan/dev/drizzle-orm/drizzle-orm
+drizzle-orm:test:types: > cd type-tests && tsc
+drizzle-orm:test:types: 
+//:lint: 
+//:lint: > @ lint /home/dan/dev/drizzle-orm
+//:lint: > eslint --ext ts .
+//:lint: 
+drizzle-orm:build: 
+drizzle-orm:build: > drizzle-orm@0.28.7 build /home/dan/dev/drizzle-orm/drizzle-orm
+drizzle-orm:build: > scripts/build.ts
+drizzle-orm:build: 
+drizzle-orm:build: $ rollup --config rollup.cjs.config.ts --configPlugin typescript
+drizzle-orm:test:types: mysql/select.ts(505,35): error TS2345: Argument of type 'MySqlSelectBase<"users_table", { id: MySqlColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }, "single", PreparedQueryHKTBase, Record<"users_table", "not-null">, true, never, { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }[], { id: MySqlColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>' is not assignable to parameter of type 'MySqlSelectQueryBuilder'.
+drizzle-orm:test:types:   The types of '_.hkt._type.$dynamic()._.hkt' are incompatible between these types.
+drizzle-orm:test:types:     Type 'MySqlSelectHKT' is not assignable to type 'MySqlSelectQueryBuilderHKT & { tableName: string | undefined; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
+drizzle-orm:test:types:       Type 'MySqlSelectHKT' is not assignable to type '{ tableName: string | undefined; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
+drizzle-orm:test:types:         Types of property 'selection' are incompatible.
+drizzle-orm:test:types:           Type 'unknown' is not assignable to type 'ColumnsSelection'.
+drizzle-orm:test:types: mysql/select.ts(507,3): error TS2344: Type 'false' does not satisfy the constraint 'true'.
+drizzle-orm:test:types: mysql/select.ts(507,24): error TS2344: Type '{ users_table: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' does not satisfy the constraint 'MySqlSelectQueryBuilderBase<MySqlSelectQueryBuilderHKT & { tableName: string | undefined; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", PreparedQueryHKTBase, Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; })>'.
+drizzle-orm:test:types:   Type '{ users_table: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' is missing the following properties from type 'MySqlSelectQueryBuilderBase<MySqlSelectQueryBuilderHKT & { tableName: string | undefined; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", PreparedQueryHKTBase, Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; })>': _, config, joinsNotNullableMap, tableName, and 20 more.
+drizzle-orm:test:types: sqlite/select.ts(510,35): error TS2345: Argument of type 'SQLiteSelectBase<"users_table", "sync", RunResult, { id: SQLiteColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }, "single", Record<"users_table", "not-null">, true, never, { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }[], { id: SQLiteColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>' is not assignable to parameter of type 'SQLiteSelectQueryBuilder'.
+drizzle-orm:test:types:   The types of '_.hkt._type.$dynamic()._.hkt' are incompatible between these types.
+drizzle-orm:test:types:     Type 'SQLiteSelectHKT' is not assignable to type 'SQLiteSelectQueryBuilderHKT & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
+drizzle-orm:test:types:       Type 'SQLiteSelectHKT' is not assignable to type '{ tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
+drizzle-orm:test:types:         Types of property 'selection' are incompatible.
+drizzle-orm:test:types:           Type 'unknown' is not assignable to type 'ColumnsSelection'.
+drizzle-orm:test:types: sqlite/select.ts(512,3): error TS2344: Type 'false' does not satisfy the constraint 'true'.
+drizzle-orm:test:types: sqlite/select.ts(512,24): error TS2344: Type '{ users_table: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' does not satisfy the constraint 'SQLiteSelectQueryBuilderBase<SQLiteSelectQueryBuilderHKT & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, "sync" | "async", unknown, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; })>'.
+drizzle-orm:test:types:   Type '{ users_table: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' is missing the following properties from type 'SQLiteSelectQueryBuilderBase<SQLiteSelectQueryBuilderHKT & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, "sync" | "async", unknown, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; })>': _, config, joinsNotNullableMap, tableName, and 19 more.
+drizzle-orm:test:types:  ELIFECYCLE  Command failed with exit code 1.
+drizzle-orm:test:types: ERROR: command finished with error: command (/home/dan/dev/drizzle-orm/drizzle-orm) pnpm run test:types exited (1)
+drizzle-orm:build:  ELIFECYCLE  Command failed.
+//:lint:  ELIFECYCLE  Command failed.
+drizzle-valibot:build: cache miss, executing 06774d0becf4d947
+drizzle-typebox:build: cache miss, executing e3bdb185e6d674a9
+drizzle-zod:build: cache miss, executing c119a2eca839b32d
+drizzle-orm#test:types: command (/home/dan/dev/drizzle-orm/drizzle-orm) pnpm run test:types exited (1)
+
+ Tasks:    0 successful, 6 total
+Cached:    0 cached, 6 total
+  Time:    1.588s 
+Failed:    drizzle-orm#test:types
+
+ ERROR  run failed: command  exited (1)
+ ELIFECYCLE  Command failed with exit code 1.
+ ELIFECYCLE  Command failed with exit code 1.
diff --git a/package.json b/package.json
index 3bbb6b284..d659f2aa0 100755
--- a/package.json
+++ b/package.json
@@ -12,29 +12,29 @@
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^4.2.0",
-    "@typescript-eslint/eslint-plugin": "^6.4.1",
+    "@typescript-eslint/eslint-plugin": "^6.7.3",
     "@typescript-eslint/experimental-utils": "^5.62.0",
-    "@typescript-eslint/parser": "^6.4.1",
-    "bun-types": "^0.7.3",
+    "@typescript-eslint/parser": "^6.7.3",
+    "bun-types": "^1.0.3",
     "concurrently": "^8.2.1",
-    "dprint": "^0.40.2",
+    "dprint": "^0.41.0",
     "drizzle-kit": "^0.19.13",
     "drizzle-orm": "workspace:./drizzle-orm/dist",
     "drizzle-orm-old": "npm:drizzle-orm@^0.27.2",
-    "eslint": "^8.47.0",
+    "eslint": "^8.50.0",
     "eslint-plugin-drizzle": "link:eslint/eslint-plugin-drizzle",
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-no-instanceof": "^1.0.1",
     "eslint-plugin-unicorn": "^48.0.1",
     "eslint-plugin-unused-imports": "^3.0.0",
-    "prettier": "^3.0.2",
-    "resolve-tspaths": "^0.8.15",
-    "turbo": "^1.10.13",
-    "typescript": "5.1.6"
+    "prettier": "^3.0.3",
+    "resolve-tspaths": "^0.8.16",
+    "turbo": "^1.10.14",
+    "typescript": "5.2.2"
   },
   "pnpm": {
     "patchedDependencies": {
-      "typescript@5.1.6": "patches/typescript@5.1.6.patch"
+      "typescript@5.2.2": "patches/typescript@5.2.2.patch"
     }
   }
 }
diff --git a/patches/typescript@5.1.6.patch b/patches/typescript@5.2.2.patch
similarity index 65%
rename from patches/typescript@5.1.6.patch
rename to patches/typescript@5.2.2.patch
index 0af94f800..e054837f8 100644
--- a/patches/typescript@5.1.6.patch
+++ b/patches/typescript@5.2.2.patch
@@ -1,8 +1,8 @@
 diff --git a/lib/tsserver.js b/lib/tsserver.js
-index 2329a12e68fc1788ad518eef084b69767f0e1a6c..9044051c1457ac05d13c9a16ddc7a8f9dc9d3640 100644
+index 382e1e2937fd02bed4c84b52f366049f2060ef1f..3ac8abaa9b30f0bcfb504220775ef8f3ee63eac3 100644
 --- a/lib/tsserver.js
 +++ b/lib/tsserver.js
-@@ -14987,7 +14987,7 @@ function isRestParameter(node) {
+@@ -15053,7 +15053,7 @@ function isRestParameter(node) {
  // src/compiler/utilities.ts
  var resolvingEmptyArray = [];
  var externalHelpersModuleNameText = "tslib";
@@ -10,4 +10,4 @@ index 2329a12e68fc1788ad518eef084b69767f0e1a6c..9044051c1457ac05d13c9a16ddc7a8f9
 +var defaultMaximumTruncationLength = 1e6;
  var noTruncationMaximumTruncationLength = 1e6;
  function getDeclarationOfKind(symbol, kind) {
-   const declarations = symbol.declarations;
\ No newline at end of file
+   const declarations = symbol.declarations;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 20aac5a33..6a490c92a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -5,9 +5,9 @@ settings:
   excludeLinksFromLockfile: false
 
 patchedDependencies:
-  typescript@5.1.6:
-    hash: nqltnu2tftypeoe37zeioxuuuq
-    path: patches/typescript@5.1.6.patch
+  typescript@5.2.2:
+    hash: wmhs4olj6eveeldp6si4l46ssq
+    path: patches/typescript@5.2.2.patch
 
 importers:
 
@@ -15,25 +15,25 @@ importers:
     devDependencies:
       '@trivago/prettier-plugin-sort-imports':
         specifier: ^4.2.0
-        version: 4.2.0(prettier@3.0.2)
+        version: 4.2.0(prettier@3.0.3)
       '@typescript-eslint/eslint-plugin':
-        specifier: ^6.4.1
-        version: 6.4.1(@typescript-eslint/parser@6.4.1)(eslint@8.47.0)(typescript@5.1.6)
+        specifier: ^6.7.3
+        version: 6.7.3(@typescript-eslint/parser@6.7.3)(eslint@8.50.0)(typescript@5.2.2)
       '@typescript-eslint/experimental-utils':
         specifier: ^5.62.0
-        version: 5.62.0(eslint@8.47.0)(typescript@5.1.6)
+        version: 5.62.0(eslint@8.50.0)(typescript@5.2.2)
       '@typescript-eslint/parser':
-        specifier: ^6.4.1
-        version: 6.4.1(eslint@8.47.0)(typescript@5.1.6)
+        specifier: ^6.7.3
+        version: 6.7.3(eslint@8.50.0)(typescript@5.2.2)
       bun-types:
-        specifier: ^0.7.3
-        version: 0.7.3
+        specifier: ^1.0.3
+        version: 1.0.3
       concurrently:
         specifier: ^8.2.1
         version: 8.2.1
       dprint:
-        specifier: ^0.40.2
-        version: 0.40.2
+        specifier: ^0.41.0
+        version: 0.41.0
       drizzle-kit:
         specifier: ^0.19.13
         version: 0.19.13
@@ -42,37 +42,37 @@ importers:
         version: link:drizzle-orm/dist
       drizzle-orm-old:
         specifier: npm:drizzle-orm@^0.27.2
-        version: /drizzle-orm@0.27.2(bun-types@0.7.3)
+        version: /drizzle-orm@0.27.2(bun-types@1.0.3)
       eslint:
-        specifier: ^8.47.0
-        version: 8.47.0
+        specifier: ^8.50.0
+        version: 8.50.0
       eslint-plugin-drizzle:
         specifier: link:eslint/eslint-plugin-drizzle
         version: link:eslint/eslint-plugin-drizzle
       eslint-plugin-import:
         specifier: ^2.28.1
-        version: 2.28.1(@typescript-eslint/parser@6.4.1)(eslint@8.47.0)
+        version: 2.28.1(@typescript-eslint/parser@6.7.3)(eslint@8.50.0)
       eslint-plugin-no-instanceof:
         specifier: ^1.0.1
         version: 1.0.1
       eslint-plugin-unicorn:
         specifier: ^48.0.1
-        version: 48.0.1(eslint@8.47.0)
+        version: 48.0.1(eslint@8.50.0)
       eslint-plugin-unused-imports:
         specifier: ^3.0.0
-        version: 3.0.0(@typescript-eslint/eslint-plugin@6.4.1)(eslint@8.47.0)
+        version: 3.0.0(@typescript-eslint/eslint-plugin@6.7.3)(eslint@8.50.0)
       prettier:
-        specifier: ^3.0.2
-        version: 3.0.2
+        specifier: ^3.0.3
+        version: 3.0.3
       resolve-tspaths:
-        specifier: ^0.8.15
-        version: 0.8.15(typescript@5.1.6)
+        specifier: ^0.8.16
+        version: 0.8.16(typescript@5.2.2)
       turbo:
-        specifier: ^1.10.13
-        version: 1.10.13
+        specifier: ^1.10.14
+        version: 1.10.14
       typescript:
-        specifier: 5.1.6
-        version: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+        specifier: 5.2.2
+        version: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
 
   drizzle-orm:
     devDependencies:
@@ -105,7 +105,7 @@ importers:
         version: 5.0.2(rollup@3.27.2)
       '@rollup/plugin-typescript':
         specifier: ^11.1.1
-        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.1.6)
+        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2)
       '@types/better-sqlite3':
         specifier: ^7.6.4
         version: 7.6.4
@@ -156,10 +156,10 @@ importers:
         version: 3.27.2
       rollup-plugin-dts:
         specifier: ^5.3.1
-        version: 5.3.1(rollup@3.27.2)(typescript@5.1.6)
+        version: 5.3.1(rollup@3.27.2)(typescript@5.2.2)
       rollup-plugin-typescript2:
         specifier: ^0.35.0
-        version: 0.35.0(rollup@3.27.2)(typescript@5.1.6)
+        version: 0.35.0(rollup@3.27.2)(typescript@5.2.2)
       sql.js:
         specifier: ^1.8.0
         version: 1.8.0
@@ -174,7 +174,7 @@ importers:
         version: 3.12.7
       vite-tsconfig-paths:
         specifier: ^4.2.0
-        version: 4.2.0(typescript@5.1.6)(vite@4.3.9)
+        version: 4.2.0(typescript@5.2.2)(vite@4.3.9)
       vitest:
         specifier: ^0.31.4
         version: 0.31.4(@vitest/ui@0.31.4)
@@ -192,7 +192,7 @@ importers:
         version: 0.4.1(rollup@3.27.2)
       '@rollup/plugin-typescript':
         specifier: ^11.1.0
-        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.1.6)
+        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2)
       '@sinclair/typebox':
         specifier: ^0.29.6
         version: 0.29.6
@@ -228,7 +228,7 @@ importers:
         version: 0.4.1(rollup@3.27.2)
       '@rollup/plugin-typescript':
         specifier: ^11.1.0
-        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.1.6)
+        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2)
       '@sinclair/typebox':
         specifier: ^0.29.6
         version: 0.29.6
@@ -267,7 +267,7 @@ importers:
         version: 0.4.1(rollup@3.20.7)
       '@rollup/plugin-typescript':
         specifier: ^11.1.0
-        version: 11.1.0(rollup@3.20.7)(typescript@5.1.6)
+        version: 11.1.0(rollup@3.20.7)(typescript@5.2.2)
       '@types/node':
         specifier: ^18.15.10
         version: 18.15.10
@@ -424,7 +424,7 @@ importers:
         version: 4.3.9(@types/node@20.2.5)
       vite-tsconfig-paths:
         specifier: ^4.2.0
-        version: 4.2.0(typescript@5.1.6)(vite@4.3.9)
+        version: 4.2.0(typescript@5.2.2)(vite@4.3.9)
 
 packages:
 
@@ -1461,6 +1461,15 @@ packages:
       chalk: 2.4.2
     dev: true
 
+  /@babel/code-frame@7.22.13:
+    resolution: {integrity: sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==}
+    engines: {node: '>=6.9.0'}
+    requiresBuild: true
+    dependencies:
+      '@babel/highlight': 7.22.20
+      chalk: 2.4.2
+    dev: true
+
   /@babel/generator@7.17.7:
     resolution: {integrity: sha512-oLcVCTeIFadUoArDTwpluncplrYBmTCCZZgXCbgNGvOBBiSDDK3eWO4b/+eOTli5tKv1lg+a5/NAXg+nTcei1w==}
     engines: {node: '>=6.9.0'}
@@ -1502,6 +1511,12 @@ packages:
     engines: {node: '>=6.9.0'}
     dev: true
 
+  /@babel/helper-validator-identifier@7.22.20:
+    resolution: {integrity: sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==}
+    engines: {node: '>=6.9.0'}
+    requiresBuild: true
+    dev: true
+
   /@babel/helper-validator-identifier@7.22.5:
     resolution: {integrity: sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==}
     engines: {node: '>=6.9.0'}
@@ -1518,6 +1533,15 @@ packages:
       js-tokens: 4.0.0
     dev: true
 
+  /@babel/highlight@7.22.20:
+    resolution: {integrity: sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.22.20
+      chalk: 2.4.2
+      js-tokens: 4.0.0
+    dev: true
+
   /@babel/parser@7.22.10:
     resolution: {integrity: sha512-lNbdGsQb9ekfsnjFGhEiF4hfFqGgfOP3H3d27re3n+CGhNuTSUEQdfWk556sTLNTloczcdM5TYF2LhzmDQKyvQ==}
     engines: {node: '>=6.0.0'}
@@ -1585,48 +1609,48 @@ packages:
     resolution: {integrity: sha512-IX4oJCe14ctblSPZBlW64BVZ9nYLUo6sD2I5gu3hX0ywByYWm1OuoKm9Xb/Zpbj8Ph18Z7Ryii6u2/ocnncXdA==}
     dev: true
 
-  /@dprint/darwin-arm64@0.40.2:
-    resolution: {integrity: sha512-qharMFhxpNq9brgvHLbqzzAgVgPWSHLfzNLwWWhKcGOUUDUIilfAo3SlvOz6w4nQiIifLpYZOvZqK7Lpf9mSSw==}
+  /@dprint/darwin-arm64@0.41.0:
+    resolution: {integrity: sha512-P9PtcQI0mrI4U6yyd+/iI664BHSqC9KTS6ogq0ptEdnLtlaWzf09D1nv6FBaHiG9m3conuBRlPsoUqt3j6PZ2w==}
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@dprint/darwin-x64@0.40.2:
-    resolution: {integrity: sha512-FPDdOTVr1JfqtLBTCvqlihWslTy3LBUoi3H1gaqIazCKMj2dB9voFWkBiMT+REMHDrlVsoSpFAfsliNr/y7HPA==}
+  /@dprint/darwin-x64@0.41.0:
+    resolution: {integrity: sha512-mSYnSoH0uyCkjgIWTny2DZAcaiRTe3kRWY5SeZECLGO37e+SdVg+ZjSzndhOvvEb9pv8EeBO1NJ9gHOSceT5Xw==}
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@dprint/linux-arm64-glibc@0.40.2:
-    resolution: {integrity: sha512-GmUWfKwEwXA+onvewX9hEJSMcd9V184+uRbEhI5tG28tBP9+IjQhrY7jCjxPvaZA+EvzNPnAy5D1wbJdlNLBNA==}
+  /@dprint/linux-arm64-glibc@0.41.0:
+    resolution: {integrity: sha512-U4xWzjjO/aAct8cSSMZFhg8l1jWy6VahXh8zWjGBufwX7t3xEcxMG9RyAp/ioYSY6wl4YXAmnUHywhC+wSjDHQ==}
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@dprint/linux-x64-glibc@0.40.2:
-    resolution: {integrity: sha512-vMHAHdsOY+2thieSWbIrIioDfPgvipwUgd0MZUWOqycTrXU6kLyi2B+5J/2Jc+QO3CiLIbumQd2FH/0vB1eWqA==}
+  /@dprint/linux-x64-glibc@0.41.0:
+    resolution: {integrity: sha512-wjv5l4mGns7E8i32E8FfAk45tw5O7v4NM17gtvhe6ggOiOD6quHowOH00pLfEakMLMF9y0J5ZO2hxJ/w06bXmQ==}
     cpu: [x64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@dprint/linux-x64-musl@0.40.2:
-    resolution: {integrity: sha512-nFSbDWd9ORyOhJ7a+RmE39WbuPoQ3OQutIgfAmfikiu/wENzEwxxv4QJ7aFnBaoZb0wuVEEpXShr8vY4p0exkg==}
+  /@dprint/linux-x64-musl@0.41.0:
+    resolution: {integrity: sha512-ZZOqiur9Xi/2uhz0Ce215VTSajAlSrduX/5k/hpIjI7Rgz22Vn77p5fmYxzWkTt/Li1zq5zboTvmGYx0QVNMrQ==}
     cpu: [x64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /@dprint/win32-x64@0.40.2:
-    resolution: {integrity: sha512-qF4VCQzFTZYD61lbQqXLU/IwUTbLK22CancO+uVtXmZRoKU9GaVjcBhMUB7URxsa8rvxWHhHT6ldillI/aOWCg==}
+  /@dprint/win32-x64@0.41.0:
+    resolution: {integrity: sha512-mFx6x4Hn848/D4gPbDm7g1wlnOh2SGoVF9c9HMGCuOobUU2WIBztzV4L5qlFCB3gprlS0ru9BhlMpGhrp0CBYA==}
     cpu: [x64]
     os: [win32]
     requiresBuild: true
@@ -2041,18 +2065,18 @@ packages:
     dev: true
     optional: true
 
-  /@eslint-community/eslint-utils@4.4.0(eslint@8.47.0):
+  /@eslint-community/eslint-utils@4.4.0(eslint@8.50.0):
     resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
     dependencies:
-      eslint: 8.47.0
+      eslint: 8.50.0
       eslint-visitor-keys: 3.4.3
     dev: true
 
-  /@eslint-community/regexpp@4.7.0:
-    resolution: {integrity: sha512-+HencqxU7CFJnQb7IKtuNBqS6Yx3Tz4kOL8BJXo+JyeiBm5MEX6pO8onXDkjrkCRlfYXS1Axro15ZjVFe9YgsA==}
+  /@eslint-community/regexpp@4.9.0:
+    resolution: {integrity: sha512-zJmuCWj2VLBt4c25CfBIbMZLGLyhkvs7LznyVX5HfpzeocThgIj5XQK4L+g3U36mMcx8bPMhGyPpwCATamC4jQ==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
     dev: true
 
@@ -2063,7 +2087,7 @@ packages:
       ajv: 6.12.6
       debug: 4.3.4
       espree: 9.6.1
-      globals: 13.21.0
+      globals: 13.22.0
       ignore: 5.2.4
       import-fresh: 3.3.0
       js-yaml: 4.1.0
@@ -2073,8 +2097,8 @@ packages:
       - supports-color
     dev: true
 
-  /@eslint/js@8.47.0:
-    resolution: {integrity: sha512-P6omY1zv5MItm93kLM8s2vr1HICJH8v0dvddDhysbIuZ+vcjOHg5Zbkf1mTkcmi2JA9oBG2anOkRnW8WJTS8Og==}
+  /@eslint/js@8.50.0:
+    resolution: {integrity: sha512-NCC3zz2+nvYd+Ckfh87rA47zfu2QsQpvc6k1yzTk+b9KzRj0wkGa8LSoGOXN6Zv4lRf/EIoZ80biDh9HOI+RNQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
@@ -2083,8 +2107,8 @@ packages:
     requiresBuild: true
     optional: true
 
-  /@humanwhocodes/config-array@0.11.10:
-    resolution: {integrity: sha512-KVVjQmNUepDVGXNuoRRdmmEjruj0KfiGSbS8LVc12LMsWDQzRXJ0qdhN8L8uUigKpfEHRhlaQFY0ib1tnUbNeQ==}
+  /@humanwhocodes/config-array@0.11.11:
+    resolution: {integrity: sha512-N2brEuAadi0CcdeMXUkhbZB84eskAc8MEX1By6qEchoVywSgXPIjou4rYsl0V3Hj0ZnuGycGCjdNgockbzeWNA==}
     engines: {node: '>=10.10.0'}
     dependencies:
       '@humanwhocodes/object-schema': 1.2.1
@@ -2379,7 +2403,7 @@ packages:
       terser: 5.17.1
     dev: true
 
-  /@rollup/plugin-typescript@11.1.0(rollup@3.20.7)(typescript@5.1.6):
+  /@rollup/plugin-typescript@11.1.0(rollup@3.20.7)(typescript@5.2.2):
     resolution: {integrity: sha512-86flrfE+bSHB69znnTV6kVjkncs2LBMhcTCyxWgRxLyfXfQrxg4UwlAqENnjrrxnSNS/XKCDJCl8EkdFJVHOxw==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
@@ -2395,10 +2419,10 @@ packages:
       '@rollup/pluginutils': 5.0.2(rollup@3.20.7)
       resolve: 1.22.1
       rollup: 3.20.7
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
-  /@rollup/plugin-typescript@11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.1.6):
+  /@rollup/plugin-typescript@11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2):
     resolution: {integrity: sha512-Ioir+x5Bejv72Lx2Zbz3/qGg7tvGbxQZALCLoJaGrkNXak/19+vKgKYJYM3i/fJxvsb23I9FuFQ8CUBEfsmBRg==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
@@ -2415,7 +2439,7 @@ packages:
       resolve: 1.22.2
       rollup: 3.27.2
       tslib: 2.5.2
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
   /@rollup/pluginutils@4.2.1:
@@ -2479,7 +2503,7 @@ packages:
     requiresBuild: true
     optional: true
 
-  /@trivago/prettier-plugin-sort-imports@4.2.0(prettier@3.0.2):
+  /@trivago/prettier-plugin-sort-imports@4.2.0(prettier@3.0.3):
     resolution: {integrity: sha512-YBepjbt+ZNBVmN3ev1amQH3lWCmHyt5qTbLCp/syXJRu/Kw2koXh44qayB1gMRxcL/gV8egmjN5xWSrYyfUtyw==}
     peerDependencies:
       '@vue/compiler-sfc': 3.x
@@ -2494,7 +2518,7 @@ packages:
       '@babel/types': 7.17.0
       javascript-natural-sort: 0.7.1
       lodash: 4.17.21
-      prettier: 3.0.2
+      prettier: 3.0.3
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -2584,6 +2608,10 @@ packages:
     resolution: {integrity: sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==}
     dev: true
 
+  /@types/json-schema@7.0.13:
+    resolution: {integrity: sha512-RbSSoHliUbnXj3ny0CNFOoxrIDV6SUGyStHsvDqosw6CkdPV8TtWGlfecuK4ToyMEAql6pzNxgCFKanovUzlgQ==}
+    dev: true
+
   /@types/json5@0.0.29:
     resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==}
     dev: true
@@ -2654,6 +2682,10 @@ packages:
     resolution: {integrity: sha512-G8hZ6XJiHnuhQKR7ZmysCeJWE08o8T0AXtk5darsCaTVsYZhhgUrq53jizaR2FvsoeCwJhlmwTjkXBY5Pn/ZHw==}
     dev: true
 
+  /@types/semver@7.5.3:
+    resolution: {integrity: sha512-OxepLK9EuNEIPxWNME+C6WwbRAOOI2o2BaQEGzz5Lu2e4Z5eDnEo+/aVEDMIXywoJitJ7xWd641wrGLZdtwRyw==}
+    dev: true
+
   /@types/serve-static@1.15.1:
     resolution: {integrity: sha512-NUo5XNiAdULrJENtJXZZ3fHtfMolzZwczzBbnAeBbqBwG+LaG6YaJtuwzwGSQZ2wsCrxjEhNNjAkKigy3n8teQ==}
     dependencies:
@@ -2687,8 +2719,8 @@ packages:
     dependencies:
       '@types/node': 20.2.5
 
-  /@typescript-eslint/eslint-plugin@6.4.1(@typescript-eslint/parser@6.4.1)(eslint@8.47.0)(typescript@5.1.6):
-    resolution: {integrity: sha512-3F5PtBzUW0dYlq77Lcqo13fv+58KDwUib3BddilE8ajPJT+faGgxmI9Sw+I8ZS22BYwoir9ZhNXcLi+S+I2bkw==}
+  /@typescript-eslint/eslint-plugin@6.7.3(@typescript-eslint/parser@6.7.3)(eslint@8.50.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-vntq452UHNltxsaaN+L9WyuMch8bMd9CqJ3zhzTPXXidwbf5mqqKCVXEuvRZUqLJSTLeWE65lQwyXsRGnXkCTA==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
@@ -2698,39 +2730,39 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@eslint-community/regexpp': 4.7.0
-      '@typescript-eslint/parser': 6.4.1(eslint@8.47.0)(typescript@5.1.6)
-      '@typescript-eslint/scope-manager': 6.4.1
-      '@typescript-eslint/type-utils': 6.4.1(eslint@8.47.0)(typescript@5.1.6)
-      '@typescript-eslint/utils': 6.4.1(eslint@8.47.0)(typescript@5.1.6)
-      '@typescript-eslint/visitor-keys': 6.4.1
+      '@eslint-community/regexpp': 4.9.0
+      '@typescript-eslint/parser': 6.7.3(eslint@8.50.0)(typescript@5.2.2)
+      '@typescript-eslint/scope-manager': 6.7.3
+      '@typescript-eslint/type-utils': 6.7.3(eslint@8.50.0)(typescript@5.2.2)
+      '@typescript-eslint/utils': 6.7.3(eslint@8.50.0)(typescript@5.2.2)
+      '@typescript-eslint/visitor-keys': 6.7.3
       debug: 4.3.4
-      eslint: 8.47.0
+      eslint: 8.50.0
       graphemer: 1.4.0
       ignore: 5.2.4
       natural-compare: 1.4.0
       semver: 7.5.4
-      ts-api-utils: 1.0.2(typescript@5.1.6)
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/experimental-utils@5.62.0(eslint@8.47.0)(typescript@5.1.6):
+  /@typescript-eslint/experimental-utils@5.62.0(eslint@8.50.0)(typescript@5.2.2):
     resolution: {integrity: sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
     dependencies:
-      '@typescript-eslint/utils': 5.62.0(eslint@8.47.0)(typescript@5.1.6)
-      eslint: 8.47.0
+      '@typescript-eslint/utils': 5.62.0(eslint@8.50.0)(typescript@5.2.2)
+      eslint: 8.50.0
     transitivePeerDependencies:
       - supports-color
       - typescript
     dev: true
 
-  /@typescript-eslint/parser@6.4.1(eslint@8.47.0)(typescript@5.1.6):
-    resolution: {integrity: sha512-610G6KHymg9V7EqOaNBMtD1GgpAmGROsmfHJPXNLCU9bfIuLrkdOygltK784F6Crboyd5tBFayPB7Sf0McrQwg==}
+  /@typescript-eslint/parser@6.7.3(eslint@8.50.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-TlutE+iep2o7R8Lf+yoer3zU6/0EAUc8QIBB3GYBc1KGz4c4TRm83xwXUZVPlZ6YCLss4r77jbu6j3sendJoiQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -2739,13 +2771,13 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 6.4.1
-      '@typescript-eslint/types': 6.4.1
-      '@typescript-eslint/typescript-estree': 6.4.1(typescript@5.1.6)
-      '@typescript-eslint/visitor-keys': 6.4.1
+      '@typescript-eslint/scope-manager': 6.7.3
+      '@typescript-eslint/types': 6.7.3
+      '@typescript-eslint/typescript-estree': 6.7.3(typescript@5.2.2)
+      '@typescript-eslint/visitor-keys': 6.7.3
       debug: 4.3.4
-      eslint: 8.47.0
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      eslint: 8.50.0
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -2758,16 +2790,16 @@ packages:
       '@typescript-eslint/visitor-keys': 5.62.0
     dev: true
 
-  /@typescript-eslint/scope-manager@6.4.1:
-    resolution: {integrity: sha512-p/OavqOQfm4/Hdrr7kvacOSFjwQ2rrDVJRPxt/o0TOWdFnjJptnjnZ+sYDR7fi4OimvIuKp+2LCkc+rt9fIW+A==}
+  /@typescript-eslint/scope-manager@6.7.3:
+    resolution: {integrity: sha512-wOlo0QnEou9cHO2TdkJmzF7DFGvAKEnB82PuPNHpT8ZKKaZu6Bm63ugOTn9fXNJtvuDPanBc78lGUGGytJoVzQ==}
     engines: {node: ^16.0.0 || >=18.0.0}
     dependencies:
-      '@typescript-eslint/types': 6.4.1
-      '@typescript-eslint/visitor-keys': 6.4.1
+      '@typescript-eslint/types': 6.7.3
+      '@typescript-eslint/visitor-keys': 6.7.3
     dev: true
 
-  /@typescript-eslint/type-utils@6.4.1(eslint@8.47.0)(typescript@5.1.6):
-    resolution: {integrity: sha512-7ON8M8NXh73SGZ5XvIqWHjgX2f+vvaOarNliGhjrJnv1vdjG0LVIz+ToYfPirOoBi56jxAKLfsLm40+RvxVVXA==}
+  /@typescript-eslint/type-utils@6.7.3(eslint@8.50.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-Fc68K0aTDrKIBvLnKTZ5Pf3MXK495YErrbHb1R6aTpfK5OdSFj0rVN7ib6Tx6ePrZ2gsjLqr0s98NG7l96KSQw==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -2776,12 +2808,12 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/typescript-estree': 6.4.1(typescript@5.1.6)
-      '@typescript-eslint/utils': 6.4.1(eslint@8.47.0)(typescript@5.1.6)
+      '@typescript-eslint/typescript-estree': 6.7.3(typescript@5.2.2)
+      '@typescript-eslint/utils': 6.7.3(eslint@8.50.0)(typescript@5.2.2)
       debug: 4.3.4
-      eslint: 8.47.0
-      ts-api-utils: 1.0.2(typescript@5.1.6)
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      eslint: 8.50.0
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -2791,12 +2823,12 @@ packages:
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
-  /@typescript-eslint/types@6.4.1:
-    resolution: {integrity: sha512-zAAopbNuYu++ijY1GV2ylCsQsi3B8QvfPHVqhGdDcbx/NK5lkqMnCGU53amAjccSpk+LfeONxwzUhDzArSfZJg==}
+  /@typescript-eslint/types@6.7.3:
+    resolution: {integrity: sha512-4g+de6roB2NFcfkZb439tigpAMnvEIg3rIjWQ+EM7IBaYt/CdJt6em9BJ4h4UpdgaBWdmx2iWsafHTrqmgIPNw==}
     engines: {node: ^16.0.0 || >=18.0.0}
     dev: true
 
-  /@typescript-eslint/typescript-estree@5.62.0(typescript@5.1.6):
+  /@typescript-eslint/typescript-estree@5.62.0(typescript@5.2.2):
     resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
@@ -2811,14 +2843,14 @@ packages:
       globby: 11.1.0
       is-glob: 4.0.3
       semver: 7.5.4
-      tsutils: 3.21.0(typescript@5.1.6)
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      tsutils: 3.21.0(typescript@5.2.2)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/typescript-estree@6.4.1(typescript@5.1.6):
-    resolution: {integrity: sha512-xF6Y7SatVE/OyV93h1xGgfOkHr2iXuo8ip0gbfzaKeGGuKiAnzS+HtVhSPx8Www243bwlW8IF7X0/B62SzFftg==}
+  /@typescript-eslint/typescript-estree@6.7.3(typescript@5.2.2):
+    resolution: {integrity: sha512-YLQ3tJoS4VxLFYHTw21oe1/vIZPRqAO91z6Uv0Ss2BKm/Ag7/RVQBcXTGcXhgJMdA4U+HrKuY5gWlJlvoaKZ5g==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       typescript: '*'
@@ -2826,31 +2858,31 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 6.4.1
-      '@typescript-eslint/visitor-keys': 6.4.1
+      '@typescript-eslint/types': 6.7.3
+      '@typescript-eslint/visitor-keys': 6.7.3
       debug: 4.3.4
       globby: 11.1.0
       is-glob: 4.0.3
       semver: 7.5.4
-      ts-api-utils: 1.0.2(typescript@5.1.6)
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /@typescript-eslint/utils@5.62.0(eslint@8.47.0)(typescript@5.1.6):
+  /@typescript-eslint/utils@5.62.0(eslint@8.50.0)(typescript@5.2.2):
     resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.50.0)
       '@types/json-schema': 7.0.12
       '@types/semver': 7.5.0
       '@typescript-eslint/scope-manager': 5.62.0
       '@typescript-eslint/types': 5.62.0
-      '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.1.6)
-      eslint: 8.47.0
+      '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.2.2)
+      eslint: 8.50.0
       eslint-scope: 5.1.1
       semver: 7.5.4
     transitivePeerDependencies:
@@ -2858,19 +2890,19 @@ packages:
       - typescript
     dev: true
 
-  /@typescript-eslint/utils@6.4.1(eslint@8.47.0)(typescript@5.1.6):
-    resolution: {integrity: sha512-F/6r2RieNeorU0zhqZNv89s9bDZSovv3bZQpUNOmmQK1L80/cV4KEu95YUJWi75u5PhboFoKUJBnZ4FQcoqhDw==}
+  /@typescript-eslint/utils@6.7.3(eslint@8.50.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-vzLkVder21GpWRrmSR9JxGZ5+ibIUSudXlW52qeKpzUEQhRSmyZiVDDj3crAth7+5tmN1ulvgKaCU2f/bPRCzg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
-      '@types/json-schema': 7.0.12
-      '@types/semver': 7.5.0
-      '@typescript-eslint/scope-manager': 6.4.1
-      '@typescript-eslint/types': 6.4.1
-      '@typescript-eslint/typescript-estree': 6.4.1(typescript@5.1.6)
-      eslint: 8.47.0
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.50.0)
+      '@types/json-schema': 7.0.13
+      '@types/semver': 7.5.3
+      '@typescript-eslint/scope-manager': 6.7.3
+      '@typescript-eslint/types': 6.7.3
+      '@typescript-eslint/typescript-estree': 6.7.3(typescript@5.2.2)
+      eslint: 8.50.0
       semver: 7.5.4
     transitivePeerDependencies:
       - supports-color
@@ -2885,11 +2917,11 @@ packages:
       eslint-visitor-keys: 3.4.3
     dev: true
 
-  /@typescript-eslint/visitor-keys@6.4.1:
-    resolution: {integrity: sha512-y/TyRJsbZPkJIZQXrHfdnxVnxyKegnpEvnRGNam7s3TRR2ykGefEWOhaef00/UUN3IZxizS7BTO3svd3lCOJRQ==}
+  /@typescript-eslint/visitor-keys@6.7.3:
+    resolution: {integrity: sha512-HEVXkU9IB+nk9o63CeICMHxFWbHWr3E1mpilIQBe9+7L/lH97rleFLVtYsfnWB+JVMaiFnEaxvknvmIzX+CqVg==}
     engines: {node: ^16.0.0 || >=18.0.0}
     dependencies:
-      '@typescript-eslint/types': 6.4.1
+      '@typescript-eslint/types': 6.7.3
       eslint-visitor-keys: 3.4.3
     dev: true
 
@@ -3464,15 +3496,15 @@ packages:
   /builtins@5.0.1:
     resolution: {integrity: sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==}
     dependencies:
-      semver: 7.5.1
+      semver: 7.5.4
     dev: false
 
   /bun-types@0.6.6:
     resolution: {integrity: sha512-/LL3zPv7d+ZvHSD6TIhVB7l8h1rrMvuGlwILTGHrJJeAaHKq+7RgIV6N8A8kzhkYMFuTq9o2P/2o8gUL7RHtzg==}
     dev: true
 
-  /bun-types@0.7.3:
-    resolution: {integrity: sha512-kssLD5mDLoawmLZFgQRRq0Wy+dca/os6TZ0MHWyFVoVAEwSrpAxmNCZ1K1GUelfhlDaL2FikRxeF9GkATdzXZg==}
+  /bun-types@1.0.3:
+    resolution: {integrity: sha512-XlyKVdYCHa7K5PHYGcwOVOrGE/bMnLS51y7zFA3ZAAXyiQ6dTaNXNCWTTufgII/6ruN770uhAXphQmzvU/r2fQ==}
     dev: true
 
   /busboy@1.6.0:
@@ -3824,7 +3856,7 @@ packages:
     requiresBuild: true
     dependencies:
       buildcheck: 0.0.6
-      nan: 2.17.0
+      nan: 2.18.0
     dev: false
     optional: true
 
@@ -4061,17 +4093,17 @@ packages:
     engines: {node: '>=12'}
     dev: false
 
-  /dprint@0.40.2:
-    resolution: {integrity: sha512-3LdyUV0itEW59UPtsRA2StOWOu8FyOW+BgvJpH/tACRHKi0z5gaQnvSxdS3mbG7dgtEhdRnGg6JoiQyGib6NTg==}
+  /dprint@0.41.0:
+    resolution: {integrity: sha512-9Ctv6EnwOy5Ai566DczI/QhAC6y+AhWDA2gFU8Zz4xezUy1BevHaIYhfdLWZQxh4Qf4H28lRu1Lq+hhIm1US9w==}
     hasBin: true
     requiresBuild: true
     optionalDependencies:
-      '@dprint/darwin-arm64': 0.40.2
-      '@dprint/darwin-x64': 0.40.2
-      '@dprint/linux-arm64-glibc': 0.40.2
-      '@dprint/linux-x64-glibc': 0.40.2
-      '@dprint/linux-x64-musl': 0.40.2
-      '@dprint/win32-x64': 0.40.2
+      '@dprint/darwin-arm64': 0.41.0
+      '@dprint/darwin-x64': 0.41.0
+      '@dprint/linux-arm64-glibc': 0.41.0
+      '@dprint/linux-x64-glibc': 0.41.0
+      '@dprint/linux-x64-musl': 0.41.0
+      '@dprint/win32-x64': 0.41.0
     dev: true
 
   /dreamopt@0.8.0:
@@ -4101,7 +4133,7 @@ packages:
       - supports-color
     dev: true
 
-  /drizzle-orm@0.27.2(bun-types@0.7.3):
+  /drizzle-orm@0.27.2(bun-types@1.0.3):
     resolution: {integrity: sha512-ZvBvceff+JlgP7FxHKe0zOU9CkZ4RcOtibumIrqfYzDGuOeF0YUY0F9iMqYpRM7pxnLRfC+oO7rWOUH3T5oFQA==}
     peerDependencies:
       '@aws-sdk/client-rds-data': '>=3'
@@ -4163,7 +4195,7 @@ packages:
       sqlite3:
         optional: true
     dependencies:
-      bun-types: 0.7.3
+      bun-types: 1.0.3
     dev: true
 
   /duplexer@0.1.2:
@@ -4645,7 +4677,7 @@ packages:
       - supports-color
     dev: true
 
-  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.4.1)(eslint-import-resolver-node@0.3.9)(eslint@8.47.0):
+  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.7.3)(eslint-import-resolver-node@0.3.9)(eslint@8.50.0):
     resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -4666,15 +4698,15 @@ packages:
       eslint-import-resolver-webpack:
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.4.1(eslint@8.47.0)(typescript@5.1.6)
+      '@typescript-eslint/parser': 6.7.3(eslint@8.50.0)(typescript@5.2.2)
       debug: 3.2.7
-      eslint: 8.47.0
+      eslint: 8.50.0
       eslint-import-resolver-node: 0.3.9
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /eslint-plugin-import@2.28.1(@typescript-eslint/parser@6.4.1)(eslint@8.47.0):
+  /eslint-plugin-import@2.28.1(@typescript-eslint/parser@6.7.3)(eslint@8.50.0):
     resolution: {integrity: sha512-9I9hFlITvOV55alzoKBI+K9q74kv0iKMeY6av5+umsNwayt59fz692daGyjR+oStBQgx6nwR9rXldDev3Clw+A==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -4684,16 +4716,16 @@ packages:
       '@typescript-eslint/parser':
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 6.4.1(eslint@8.47.0)(typescript@5.1.6)
+      '@typescript-eslint/parser': 6.7.3(eslint@8.50.0)(typescript@5.2.2)
       array-includes: 3.1.6
       array.prototype.findlastindex: 1.2.2
       array.prototype.flat: 1.3.1
       array.prototype.flatmap: 1.3.1
       debug: 3.2.7
       doctrine: 2.1.0
-      eslint: 8.47.0
+      eslint: 8.50.0
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.4.1)(eslint-import-resolver-node@0.3.9)(eslint@8.47.0)
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.7.3)(eslint-import-resolver-node@0.3.9)(eslint@8.50.0)
       has: 1.0.3
       is-core-module: 2.13.0
       is-glob: 4.0.3
@@ -4713,17 +4745,17 @@ packages:
     resolution: {integrity: sha512-zlqQ7EsfzbRO68uI+p8FIE7zYB4njs+nNbkNjSb5QmLi2et67zQLqSeaao5U9SpnlZTTJC87nS2oyHo2ACtajw==}
     dev: true
 
-  /eslint-plugin-unicorn@48.0.1(eslint@8.47.0):
+  /eslint-plugin-unicorn@48.0.1(eslint@8.50.0):
     resolution: {integrity: sha512-FW+4r20myG/DqFcCSzoumaddKBicIPeFnTrifon2mWIzlfyvzwyqZjqVP7m4Cqr/ZYisS2aiLghkUWaPg6vtCw==}
     engines: {node: '>=16'}
     peerDependencies:
       eslint: '>=8.44.0'
     dependencies:
       '@babel/helper-validator-identifier': 7.22.5
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.50.0)
       ci-info: 3.8.0
       clean-regexp: 1.0.0
-      eslint: 8.47.0
+      eslint: 8.50.0
       esquery: 1.5.0
       indent-string: 4.0.0
       is-builtin-module: 3.2.1
@@ -4737,7 +4769,7 @@ packages:
       strip-indent: 3.0.0
     dev: true
 
-  /eslint-plugin-unused-imports@3.0.0(@typescript-eslint/eslint-plugin@6.4.1)(eslint@8.47.0):
+  /eslint-plugin-unused-imports@3.0.0(@typescript-eslint/eslint-plugin@6.7.3)(eslint@8.50.0):
     resolution: {integrity: sha512-sduiswLJfZHeeBJ+MQaG+xYzSWdRXoSw61DpU13mzWumCkR0ufD0HmO4kdNokjrkluMHpj/7PJeN35pgbhW3kw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
@@ -4747,8 +4779,8 @@ packages:
       '@typescript-eslint/eslint-plugin':
         optional: true
     dependencies:
-      '@typescript-eslint/eslint-plugin': 6.4.1(@typescript-eslint/parser@6.4.1)(eslint@8.47.0)(typescript@5.1.6)
-      eslint: 8.47.0
+      '@typescript-eslint/eslint-plugin': 6.7.3(@typescript-eslint/parser@6.7.3)(eslint@8.50.0)(typescript@5.2.2)
+      eslint: 8.50.0
       eslint-rule-composer: 0.3.0
     dev: true
 
@@ -4778,16 +4810,16 @@ packages:
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
-  /eslint@8.47.0:
-    resolution: {integrity: sha512-spUQWrdPt+pRVP1TTJLmfRNJJHHZryFmptzcafwSvHsceV81djHOdnEeDmkdotZyLNjDhrOasNK8nikkoG1O8Q==}
+  /eslint@8.50.0:
+    resolution: {integrity: sha512-FOnOGSuFuFLv/Sa+FDVRZl4GGVAAFFi8LecRsI5a1tMO5HIE8nCm4ivAlzt4dT3ol/PaaGC0rJEEXQmHJBGoOg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     hasBin: true
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
-      '@eslint-community/regexpp': 4.7.0
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.50.0)
+      '@eslint-community/regexpp': 4.9.0
       '@eslint/eslintrc': 2.1.2
-      '@eslint/js': 8.47.0
-      '@humanwhocodes/config-array': 0.11.10
+      '@eslint/js': 8.50.0
+      '@humanwhocodes/config-array': 0.11.11
       '@humanwhocodes/module-importer': 1.0.1
       '@nodelib/fs.walk': 1.2.8
       ajv: 6.12.6
@@ -4805,7 +4837,7 @@ packages:
       file-entry-cache: 6.0.1
       find-up: 5.0.0
       glob-parent: 6.0.2
-      globals: 13.21.0
+      globals: 13.22.0
       graphemer: 1.4.0
       ignore: 5.2.4
       imurmurhash: 0.1.4
@@ -5039,7 +5071,7 @@ packages:
     resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==}
     engines: {node: ^10.12.0 || >=12.0.0}
     dependencies:
-      flat-cache: 3.0.4
+      flat-cache: 3.1.0
     dev: true
 
   /file-uri-to-path@1.0.0:
@@ -5099,17 +5131,22 @@ packages:
       path-exists: 5.0.0
     dev: true
 
-  /flat-cache@3.0.4:
-    resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==}
-    engines: {node: ^10.12.0 || >=12.0.0}
+  /flat-cache@3.1.0:
+    resolution: {integrity: sha512-OHx4Qwrrt0E4jEIcI5/Xb+f+QmJYNj2rrK8wiIdQOIrB9WrrJL8cjZvXdXuBTkkEwEqLycb5BeZDV1o2i9bTew==}
+    engines: {node: '>=12.0.0'}
     dependencies:
-      flatted: 3.2.7
+      flatted: 3.2.9
+      keyv: 4.5.3
       rimraf: 3.0.2
     dev: true
 
   /flatted@3.2.7:
     resolution: {integrity: sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==}
 
+  /flatted@3.2.9:
+    resolution: {integrity: sha512-36yxDn5H7OFZQla0/jFJmbIKTdZAQHngCedGxiMmpNfEZM0sdEeT+WczLQrjK6D7o2aiyLYDnkw0R3JK0Qv1RQ==}
+    dev: true
+
   /follow-redirects@1.15.2:
     resolution: {integrity: sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==}
     engines: {node: '>=4.0'}
@@ -5375,8 +5412,8 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
-  /globals@13.21.0:
-    resolution: {integrity: sha512-ybyme3s4yy/t/3s35bewwXKOf7cvzfreG2lH0lZl0JB7I4GxRP2ghxOK/Nb9EkRXdbBXZLfq/p/0W2JUONB/Gg==}
+  /globals@13.22.0:
+    resolution: {integrity: sha512-H1Ddc/PbZHTDVJSnj8kWptIRSD6AM3pK+mKytuIVF4uoBV7rshFlhhvA58ceJ5wp3Er58w6zj7bykMpYXt3ETw==}
     engines: {node: '>=8'}
     dependencies:
       type-fest: 0.20.2
@@ -5905,6 +5942,10 @@ packages:
     hasBin: true
     dev: true
 
+  /json-buffer@3.0.1:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+    dev: true
+
   /json-diff@0.9.0:
     resolution: {integrity: sha512-cVnggDrVkAAA3OvFfHpFEhOnmcsUpleEKq4d4O8sQWWSH40MBrWstKigVB1kGrgLWzuom+7rRdaCsnBD6VyObQ==}
     hasBin: true
@@ -5963,6 +6004,12 @@ packages:
     engines: {node: '>=12.20'}
     dev: true
 
+  /keyv@4.5.3:
+    resolution: {integrity: sha512-QCiSav9WaX1PgETJ+SpNnx2PRRapJ/oRSXM4VO5OGYGSjrxbKPVFVhB3l2OCbLCk329N8qyAtsJjSjvVBWzEug==}
+    dependencies:
+      json-buffer: 3.0.1
+    dev: true
+
   /kleur@4.1.5:
     resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
     engines: {node: '>=6'}
@@ -6134,7 +6181,7 @@ packages:
     resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
     engines: {node: '>=8'}
     dependencies:
-      semver: 6.3.0
+      semver: 6.3.1
 
   /make-fetch-happen@9.1.0:
     resolution: {integrity: sha512-+zopwDy7DNknmwPQplem5lAZX/eCOzSvSNNcSKm5eVwTkOBzoktEfXsa9L23J/GIRhxRsaxzkPEhrJEpE2F4Gg==}
@@ -6421,8 +6468,8 @@ packages:
     dependencies:
       lru-cache: 7.18.3
 
-  /nan@2.17.0:
-    resolution: {integrity: sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ==}
+  /nan@2.18.0:
+    resolution: {integrity: sha512-W7tfG7vMOGtD30sHoZSSc/JVYiyDPEyQVso/Zz+/uQd0B0L46gtC+pHha5FFMRpil6fm/AoEcRWyOVi4+E/f8w==}
     requiresBuild: true
     dev: false
     optional: true
@@ -6456,7 +6503,7 @@ packages:
     resolution: {integrity: sha512-zNy02qivjjRosswoYmPi8hIKJRr8MpQyeKT6qlcq/OnOgA3Rhoae+IYOqsM9V5+JnHWmxKnWOT2GxvtqdtOCXA==}
     engines: {node: '>=10'}
     dependencies:
-      semver: 7.5.1
+      semver: 7.5.4
 
   /node-addon-api@4.3.0:
     resolution: {integrity: sha512-73sE9+3UaLYYFmDsFZnqCInzPyh3MqIwZO9cw58yIqAZhONrrabrYyYe3TuIqtIiOuTXVhsGau8hcrhhwSsDIQ==}
@@ -6579,7 +6626,7 @@ packages:
     dependencies:
       execa: 6.1.0
       parse-package-name: 1.0.0
-      semver: 7.5.1
+      semver: 7.5.4
       validate-npm-package-name: 4.0.0
     dev: false
 
@@ -6769,7 +6816,7 @@ packages:
     resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
     engines: {node: '>=8'}
     dependencies:
-      '@babel/code-frame': 7.22.10
+      '@babel/code-frame': 7.22.13
       error-ex: 1.3.2
       json-parse-even-better-errors: 2.3.1
       lines-and-columns: 1.2.4
@@ -7036,8 +7083,8 @@ packages:
     engines: {node: '>= 0.8.0'}
     dev: true
 
-  /prettier@3.0.2:
-    resolution: {integrity: sha512-o2YR9qtniXvwEZlOKbveKfDQVyqxbEIWn48Z8m3ZJjBjcCmUy3xZGIv+7AkaeuaTr6yPXJjwv07ZWlsWbEy1rQ==}
+  /prettier@3.0.3:
+    resolution: {integrity: sha512-L/4pUDMxcNa8R/EthV08Zt42WBO4h1rarVtK0K+QJG0X187OLo7l699jWw0GKuwzkPQ//jMFA/8Xm6Fh3J/DAg==}
     engines: {node: '>=14'}
     hasBin: true
     dev: true
@@ -7237,8 +7284,8 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /resolve-tspaths@0.8.15(typescript@5.1.6):
-    resolution: {integrity: sha512-uqxasvZ7WGMfaozpwSLo5nEV/TBnbwMSV7df7hLfwtmGNQlqO1ljcTJ5s8EX9MidKlMQLnczCwur9gFtbOc6pA==}
+  /resolve-tspaths@0.8.16(typescript@5.2.2):
+    resolution: {integrity: sha512-5c90plgcKFcCk66Ve1vFh6tm0fLKmSz6vaW4CezP6i69Q8fgWX3YGPYmKPEughem+nPHT1358P+rXrhw5pibwg==}
     hasBin: true
     peerDependencies:
       typescript: '>=3.0.3'
@@ -7246,7 +7293,7 @@ packages:
       ansi-colors: 4.1.3
       commander: 11.0.0
       fast-glob: 3.3.1
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
   /resolve@1.22.1:
@@ -7300,7 +7347,7 @@ packages:
       glob: 10.2.2
     dev: true
 
-  /rollup-plugin-dts@5.3.1(rollup@3.27.2)(typescript@5.1.6):
+  /rollup-plugin-dts@5.3.1(rollup@3.27.2)(typescript@5.2.2):
     resolution: {integrity: sha512-gusMi+Z4gY/JaEQeXnB0RUdU82h1kF0WYzCWgVmV4p3hWXqelaKuCvcJawfeg+EKn2T1Ie+YWF2OiN1/L8bTVg==}
     engines: {node: '>=v14.21.3'}
     peerDependencies:
@@ -7309,12 +7356,12 @@ packages:
     dependencies:
       magic-string: 0.30.2
       rollup: 3.27.2
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     optionalDependencies:
-      '@babel/code-frame': 7.22.10
+      '@babel/code-frame': 7.22.13
     dev: true
 
-  /rollup-plugin-typescript2@0.35.0(rollup@3.27.2)(typescript@5.1.6):
+  /rollup-plugin-typescript2@0.35.0(rollup@3.27.2)(typescript@5.2.2):
     resolution: {integrity: sha512-szcIO9hPUx3PhQl91u4pfNAH2EKbtrXaES+m163xQVE5O1CC0ea6YZV/5woiDDW3CR9jF2CszPrKN+AFiND0bg==}
     peerDependencies:
       rollup: '>=1.26.3'
@@ -7326,7 +7373,7 @@ packages:
       rollup: 3.27.2
       semver: 7.5.1
       tslib: 2.5.3
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
   /rollup@3.20.7:
@@ -7391,14 +7438,9 @@ packages:
     hasBin: true
     dev: true
 
-  /semver@6.3.0:
-    resolution: {integrity: sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==}
-    hasBin: true
-
   /semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
-    dev: true
 
   /semver@7.5.1:
     resolution: {integrity: sha512-Wvss5ivl8TMRZXXESstBA4uR5iXgEN/VC5/sOcuXdVLzcdkz4HWetIoRfG5gb5X+ij/G9rw9YoGn3QoQ8OCSpw==}
@@ -7679,7 +7721,7 @@ packages:
       bcrypt-pbkdf: 1.0.2
     optionalDependencies:
       cpu-features: 0.0.9
-      nan: 2.17.0
+      nan: 2.18.0
     dev: false
 
   /ssri@8.0.1:
@@ -7989,16 +8031,16 @@ packages:
     engines: {node: '>=0.6'}
     dev: false
 
-  /ts-api-utils@1.0.2(typescript@5.1.6):
-    resolution: {integrity: sha512-Cbu4nIqnEdd+THNEsBdkolnOXhg0I8XteoHaEKgvsxpsbWda4IsUut2c187HxywQCvveojow0Dgw/amxtSKVkQ==}
+  /ts-api-utils@1.0.3(typescript@5.2.2):
+    resolution: {integrity: sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg==}
     engines: {node: '>=16.13.0'}
     peerDependencies:
       typescript: '>=4.2.0'
     dependencies:
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
-  /tsconfck@2.1.1(typescript@5.1.6):
+  /tsconfck@2.1.1(typescript@5.2.2):
     resolution: {integrity: sha512-ZPCkJBKASZBmBUNqGHmRhdhM8pJYDdOXp4nRgj/O0JwUwsMq50lCDRQP/M5GBNAA0elPrq4gAeu4dkaVCuKWww==}
     engines: {node: ^14.13.1 || ^16 || >=18}
     hasBin: true
@@ -8008,7 +8050,7 @@ packages:
       typescript:
         optional: true
     dependencies:
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
   /tsconfig-paths@3.14.2:
@@ -8034,14 +8076,14 @@ packages:
     resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==}
     dev: true
 
-  /tsutils@3.21.0(typescript@5.1.6):
+  /tsutils@3.21.0(typescript@5.2.2):
     resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
     engines: {node: '>= 6'}
     peerDependencies:
       typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
     dependencies:
       tslib: 1.14.1
-      typescript: 5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
   /tsx@3.12.6:
@@ -8071,64 +8113,64 @@ packages:
     dependencies:
       safe-buffer: 5.2.1
 
-  /turbo-darwin-64@1.10.13:
-    resolution: {integrity: sha512-vmngGfa2dlYvX7UFVncsNDMuT4X2KPyPJ2Jj+xvf5nvQnZR/3IeDEGleGVuMi/hRzdinoxwXqgk9flEmAYp0Xw==}
+  /turbo-darwin-64@1.10.14:
+    resolution: {integrity: sha512-I8RtFk1b9UILAExPdG/XRgGQz95nmXPE7OiGb6ytjtNIR5/UZBS/xVX/7HYpCdmfriKdVwBKhalCoV4oDvAGEg==}
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-darwin-arm64@1.10.13:
-    resolution: {integrity: sha512-eMoJC+k7gIS4i2qL6rKmrIQGP6Wr9nN4odzzgHFngLTMimok2cGLK3qbJs5O5F/XAtEeRAmuxeRnzQwTl/iuAw==}
+  /turbo-darwin-arm64@1.10.14:
+    resolution: {integrity: sha512-KAdUWryJi/XX7OD0alOuOa0aJ5TLyd4DNIYkHPHYcM6/d7YAovYvxRNwmx9iv6Vx6IkzTnLeTiUB8zy69QkG9Q==}
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-linux-64@1.10.13:
-    resolution: {integrity: sha512-0CyYmnKTs6kcx7+JRH3nPEqCnzWduM0hj8GP/aodhaIkLNSAGAa+RiYZz6C7IXN+xUVh5rrWTnU2f1SkIy7Gdg==}
+  /turbo-linux-64@1.10.14:
+    resolution: {integrity: sha512-BOBzoREC2u4Vgpap/WDxM6wETVqVMRcM8OZw4hWzqCj2bqbQ6L0wxs1LCLWVrghQf93JBQtIGAdFFLyCSBXjWQ==}
     cpu: [x64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-linux-arm64@1.10.13:
-    resolution: {integrity: sha512-0iBKviSGQQlh2OjZgBsGjkPXoxvRIxrrLLbLObwJo3sOjIH0loGmVIimGS5E323soMfi/o+sidjk2wU1kFfD7Q==}
+  /turbo-linux-arm64@1.10.14:
+    resolution: {integrity: sha512-D8T6XxoTdN5D4V5qE2VZG+/lbZX/89BkAEHzXcsSUTRjrwfMepT3d2z8aT6hxv4yu8EDdooZq/2Bn/vjMI32xw==}
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-windows-64@1.10.13:
-    resolution: {integrity: sha512-S5XySRfW2AmnTeY1IT+Jdr6Goq7mxWganVFfrmqU+qqq3Om/nr0GkcUX+KTIo9mPrN0D3p5QViBRzulwB5iuUQ==}
+  /turbo-windows-64@1.10.14:
+    resolution: {integrity: sha512-zKNS3c1w4i6432N0cexZ20r/aIhV62g69opUn82FLVs/zk3Ie0GVkSB6h0rqIvMalCp7enIR87LkPSDGz9K4UA==}
     cpu: [x64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-windows-arm64@1.10.13:
-    resolution: {integrity: sha512-nKol6+CyiExJIuoIc3exUQPIBjP9nIq5SkMJgJuxsot2hkgGrafAg/izVDRDrRduQcXj2s8LdtxJHvvnbI8hEQ==}
+  /turbo-windows-arm64@1.10.14:
+    resolution: {integrity: sha512-rkBwrTPTxNSOUF7of8eVvvM+BkfkhA2OvpHM94if8tVsU+khrjglilp8MTVPHlyS9byfemPAmFN90oRIPB05BA==}
     cpu: [arm64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo@1.10.13:
-    resolution: {integrity: sha512-vOF5IPytgQPIsgGtT0n2uGZizR2N3kKuPIn4b5p5DdeLoI0BV7uNiydT7eSzdkPRpdXNnO8UwS658VaI4+YSzQ==}
+  /turbo@1.10.14:
+    resolution: {integrity: sha512-hr9wDNYcsee+vLkCDIm8qTtwhJ6+UAMJc3nIY6+PNgUTtXcQgHxCq8BGoL7gbABvNWv76CNbK5qL4Lp9G3ZYRA==}
     hasBin: true
     optionalDependencies:
-      turbo-darwin-64: 1.10.13
-      turbo-darwin-arm64: 1.10.13
-      turbo-linux-64: 1.10.13
-      turbo-linux-arm64: 1.10.13
-      turbo-windows-64: 1.10.13
-      turbo-windows-arm64: 1.10.13
+      turbo-darwin-64: 1.10.14
+      turbo-darwin-arm64: 1.10.14
+      turbo-linux-64: 1.10.14
+      turbo-linux-arm64: 1.10.14
+      turbo-windows-64: 1.10.14
+      turbo-windows-arm64: 1.10.14
     dev: true
 
   /tweetnacl@0.14.5:
@@ -8220,8 +8262,8 @@ packages:
       is-typed-array: 1.1.12
     dev: true
 
-  /typescript@5.1.6(patch_hash=nqltnu2tftypeoe37zeioxuuuq):
-    resolution: {integrity: sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==}
+  /typescript@5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq):
+    resolution: {integrity: sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==}
     engines: {node: '>=14.17'}
     hasBin: true
     dev: true
@@ -8358,7 +8400,7 @@ packages:
       - supports-color
       - terser
 
-  /vite-tsconfig-paths@4.2.0(typescript@5.1.6)(vite@4.3.9):
+  /vite-tsconfig-paths@4.2.0(typescript@5.2.2)(vite@4.3.9):
     resolution: {integrity: sha512-jGpus0eUy5qbbMVGiTxCL1iB9ZGN6Bd37VGLJU39kTDD6ZfULTTb1bcc5IeTWqWJKiWV5YihCaibeASPiGi8kw==}
     peerDependencies:
       vite: '*'
@@ -8368,7 +8410,7 @@ packages:
     dependencies:
       debug: 4.3.4
       globrex: 0.1.2
-      tsconfck: 2.1.1(typescript@5.1.6)
+      tsconfck: 2.1.1(typescript@5.2.2)
       vite: 4.3.9(@types/node@20.2.5)
     transitivePeerDependencies:
       - supports-color
diff --git a/tsconfig.json b/tsconfig.json
index 433128324..903afcafe 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,7 +4,7 @@
 		"composite": false,
 		"target": "esnext",
 		"module": "esnext",
-		"moduleResolution": "node",
+		"moduleResolution": "bundler",
 		"lib": ["es2020", "es2018", "es2017", "es7", "es6", "es5"],
 		"declaration": false /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
 		"declarationMap": false,
@@ -34,7 +34,8 @@
 		"allowUnreachableCode": false /* Disable error reporting for unreachable code. */,
 		"skipLibCheck": true /* Skip type checking all .d.ts files. */,
 		"noErrorTruncation": true /* Disable truncating types in error messages. */,
-		"checkJs": true
+		"checkJs": true,
+		"allowImportingTsExtensions": true
 	},
 	"exclude": ["**/dist"],
 	"ts-node": {

From 94c3c95fd569ee6ae5c75e6a15aa32ab3da4ae0d Mon Sep 17 00:00:00 2001
From: Roman <nabukhotnyiroman@gmail.com>
Date: Mon, 2 Oct 2023 10:45:15 +0300
Subject: [PATCH 33/72] feat: Add pg and mysql proxies

---
 drizzle-orm/rollup.common.ts                  |    4 +
 drizzle-orm/src/mysql-proxy/driver.ts         |   50 +
 drizzle-orm/src/mysql-proxy/index.ts          |    2 +
 drizzle-orm/src/mysql-proxy/migrator.ts       |   50 +
 drizzle-orm/src/mysql-proxy/session.ts        |  127 +
 drizzle-orm/src/pg-proxy/driver.ts            |   50 +
 drizzle-orm/src/pg-proxy/index.ts             |    2 +
 drizzle-orm/src/pg-proxy/migrator.ts          |   47 +
 drizzle-orm/src/pg-proxy/session.ts           |  127 +
 examples/mysql-proxy/.gitignore               |    2 +
 examples/mysql-proxy/README.md                |  178 ++
 .../drizzle/0000_ambiguous_marvel_boy.sql     |   15 +
 .../drizzle/meta/0000_snapshot.json           |  102 +
 .../mysql-proxy/drizzle/meta/_journal.json    |   13 +
 examples/mysql-proxy/package-lock.json        | 1796 ++++++++++++
 examples/mysql-proxy/package.json             |   25 +
 examples/mysql-proxy/src/index.ts             |   36 +
 examples/mysql-proxy/src/schema.ts            |   13 +
 examples/mysql-proxy/src/server.ts            |   74 +
 examples/mysql-proxy/tsconfig.json            |   26 +
 examples/pg-proxy/.gitignore                  |    2 +
 examples/pg-proxy/README.md                   |  162 ++
 .../pg-proxy/drizzle/0000_loving_gravity.sql  |   17 +
 .../pg-proxy/drizzle/meta/0000_snapshot.json  |   85 +
 examples/pg-proxy/drizzle/meta/_journal.json  |   13 +
 examples/pg-proxy/package-lock.json           | 1938 +++++++++++++
 examples/pg-proxy/package.json                |   27 +
 examples/pg-proxy/src/index.ts                |   38 +
 examples/pg-proxy/src/schema.ts               |   13 +
 examples/pg-proxy/src/server.ts               |   58 +
 examples/pg-proxy/tsconfig.json               |   26 +
 integration-tests/test.ts                     |  204 ++
 integration-tests/tests/imports.test.cjs      |    4 +
 integration-tests/tests/imports.test.mjs      |    4 +
 integration-tests/tests/mysql-proxy.test.ts   | 2111 ++++++++++++++
 integration-tests/tests/pg-proxy.test.ts      | 2584 +++++++++++++++++
 36 files changed, 10025 insertions(+)
 create mode 100644 drizzle-orm/src/mysql-proxy/driver.ts
 create mode 100644 drizzle-orm/src/mysql-proxy/index.ts
 create mode 100644 drizzle-orm/src/mysql-proxy/migrator.ts
 create mode 100644 drizzle-orm/src/mysql-proxy/session.ts
 create mode 100644 drizzle-orm/src/pg-proxy/driver.ts
 create mode 100644 drizzle-orm/src/pg-proxy/index.ts
 create mode 100644 drizzle-orm/src/pg-proxy/migrator.ts
 create mode 100644 drizzle-orm/src/pg-proxy/session.ts
 create mode 100644 examples/mysql-proxy/.gitignore
 create mode 100644 examples/mysql-proxy/README.md
 create mode 100644 examples/mysql-proxy/drizzle/0000_ambiguous_marvel_boy.sql
 create mode 100644 examples/mysql-proxy/drizzle/meta/0000_snapshot.json
 create mode 100644 examples/mysql-proxy/drizzle/meta/_journal.json
 create mode 100644 examples/mysql-proxy/package-lock.json
 create mode 100644 examples/mysql-proxy/package.json
 create mode 100644 examples/mysql-proxy/src/index.ts
 create mode 100644 examples/mysql-proxy/src/schema.ts
 create mode 100644 examples/mysql-proxy/src/server.ts
 create mode 100644 examples/mysql-proxy/tsconfig.json
 create mode 100644 examples/pg-proxy/.gitignore
 create mode 100644 examples/pg-proxy/README.md
 create mode 100644 examples/pg-proxy/drizzle/0000_loving_gravity.sql
 create mode 100644 examples/pg-proxy/drizzle/meta/0000_snapshot.json
 create mode 100644 examples/pg-proxy/drizzle/meta/_journal.json
 create mode 100644 examples/pg-proxy/package-lock.json
 create mode 100644 examples/pg-proxy/package.json
 create mode 100644 examples/pg-proxy/src/index.ts
 create mode 100644 examples/pg-proxy/src/schema.ts
 create mode 100644 examples/pg-proxy/src/server.ts
 create mode 100644 examples/pg-proxy/tsconfig.json
 create mode 100644 integration-tests/test.ts
 create mode 100644 integration-tests/tests/mysql-proxy.test.ts
 create mode 100644 integration-tests/tests/pg-proxy.test.ts

diff --git a/drizzle-orm/rollup.common.ts b/drizzle-orm/rollup.common.ts
index 741c1c38f..b4f6cfd08 100644
--- a/drizzle-orm/rollup.common.ts
+++ b/drizzle-orm/rollup.common.ts
@@ -33,6 +33,10 @@ export const entries = [
 	'sqlite-core/index',
 	'sqlite-proxy/index',
 	'sqlite-proxy/migrator',
+	'pg-proxy/index',
+	'pg-proxy/migrator',
+	'mysql-proxy/index',
+	'mysql-proxy/migrator',
 	'migrator',
 	'version',
 ];
diff --git a/drizzle-orm/src/mysql-proxy/driver.ts b/drizzle-orm/src/mysql-proxy/driver.ts
new file mode 100644
index 000000000..f807f6c56
--- /dev/null
+++ b/drizzle-orm/src/mysql-proxy/driver.ts
@@ -0,0 +1,50 @@
+import { DefaultLogger } from '~/logger.ts';
+import { MySqlDatabase } from '~/mysql-core/db.ts';
+import { MySqlDialect } from '~/mysql-core/dialect.ts';
+import {
+	createTableRelationsHelpers,
+	extractTablesRelationalConfig,
+	type RelationalSchemaConfig,
+	type TablesRelationalConfig,
+} from '~/relations.ts';
+import { type DrizzleConfig } from '~/utils.ts';
+import { MySqlRemoteSession, type MySqlRemoteQueryResultHKT, type MySqlRemotePreparedQueryHKT } from './session.ts';
+
+export type MySqlRemoteDatabase<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+> = MySqlDatabase<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT,  TSchema>;
+
+export type RemoteCallback = (
+	sql: string,
+	params: any[],
+	method: 'all' | 'execute'
+) => Promise<{ rows: any[] }>;
+
+export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+	callback: RemoteCallback,
+	config: DrizzleConfig<TSchema> = {},
+): MySqlRemoteDatabase<TSchema> {
+	const dialect = new MySqlDialect();
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
+	if (config.schema) {
+		const tablesConfig = extractTablesRelationalConfig(
+			config.schema,
+			createTableRelationsHelpers,
+		);
+		schema = {
+			fullSchema: config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap,
+		};
+	}
+
+	const session = new MySqlRemoteSession(callback, dialect, schema, { logger });
+	return new MySqlDatabase(dialect, session, schema, 'default') as MySqlRemoteDatabase<TSchema>;
+}
diff --git a/drizzle-orm/src/mysql-proxy/index.ts b/drizzle-orm/src/mysql-proxy/index.ts
new file mode 100644
index 000000000..b1b6a52e7
--- /dev/null
+++ b/drizzle-orm/src/mysql-proxy/index.ts
@@ -0,0 +1,2 @@
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/mysql-proxy/migrator.ts b/drizzle-orm/src/mysql-proxy/migrator.ts
new file mode 100644
index 000000000..1ca0e799b
--- /dev/null
+++ b/drizzle-orm/src/mysql-proxy/migrator.ts
@@ -0,0 +1,50 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { sql } from '~/sql/index.ts';
+import type { MySqlRemoteDatabase } from './driver.ts';
+
+export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
+
+export async function migrate<TSchema extends Record<string, unknown>>(
+	db: MySqlRemoteDatabase<TSchema>,
+	callback: ProxyMigrator,
+	config: MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	
+	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
+	const migrationTableCreate = sql`
+		create table if not exists ${sql.identifier(migrationsTable)} (
+			id serial primary key,
+			hash text not null,
+			created_at bigint
+		)
+	`;
+	await db.execute(migrationTableCreate);
+
+	const dbMigrations = await db.select({
+		id: sql.raw('id'),
+		hash: sql.raw('hash'),
+		created_at: sql.raw('created_at'),
+	}).from(sql.raw(migrationsTable)).orderBy(
+		sql.raw('created_at desc')
+	).limit(1);
+
+	const lastDbMigration = dbMigrations[0];
+
+	const queriesToRun: string[] = [];
+
+	for (const migration of migrations) {
+		if (
+			!lastDbMigration
+			|| Number(lastDbMigration.created_at) < migration.folderMillis
+		) {
+			queriesToRun.push(
+				...migration.sql,
+				`insert into ${sql.identifier(migrationsTable)} (\`hash\`, \`created_at\`) values(${migration.hash}, ${migration.folderMillis})`,
+			);
+		}
+	}
+
+	await callback(queriesToRun);
+}
diff --git a/drizzle-orm/src/mysql-proxy/session.ts b/drizzle-orm/src/mysql-proxy/session.ts
new file mode 100644
index 000000000..e9d660d4d
--- /dev/null
+++ b/drizzle-orm/src/mysql-proxy/session.ts
@@ -0,0 +1,127 @@
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import { MySqlTransaction } from '~/mysql-core/index.ts';
+import type { SelectedFieldsOrdered } from '~/mysql-core/query-builders/select.types.ts';
+import type { MySqlTransactionConfig, QueryResultHKT , PreparedQueryConfig, PreparedQueryHKT, PreparedQueryKind } from '~/mysql-core/session.ts';
+import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import { fillPlaceholders} from '~/sql/index.ts';
+import type { SQL, Query } from '~/sql/index.ts';
+import { mapResultRow, type Assume } from '~/utils.ts';
+import { type RemoteCallback } from './driver.ts';
+import { MySqlSession, PreparedQuery as PreparedQueryBase } from '~/mysql-core/session.ts';
+import type { MySqlDialect } from '~/mysql-core/dialect.ts';
+import {
+	type FieldPacket,
+	type ResultSetHeader,
+} from 'mysql2/promise';
+
+export type MySqlRawQueryResult = [ResultSetHeader, FieldPacket[]];
+
+export interface MySqlRemoteSessionOptions {
+	logger?: Logger;
+}
+
+export class MySqlRemoteSession<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends TablesRelationalConfig,
+> extends MySqlSession<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT, TFullSchema, TSchema> {
+	static readonly [entityKind]: string = 'MySqlRemoteSession';
+
+	private logger: Logger;
+
+	constructor(
+		private client: RemoteCallback,
+		dialect: MySqlDialect,
+		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		options: MySqlRemoteSessionOptions,
+	) {
+		super(dialect);
+		this.logger = options.logger ?? new NoopLogger();
+	}
+
+	prepareQuery<T extends PreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		customResultMapper?: (rows: unknown[][]) => T['execute'],
+	): PreparedQueryKind<MySqlRemotePreparedQueryHKT, T> {
+		return new PreparedQuery(this.client, query.sql, query.params, this.logger, fields, customResultMapper) as PreparedQueryKind<MySqlRemotePreparedQueryHKT, T>;
+	}
+
+	override all<T = unknown>(query: SQL): Promise<T[]> {
+		const querySql = this.dialect.sqlToQuery(query);
+		this.logger.logQuery(querySql.sql, querySql.params);
+		return this.client(querySql.sql, querySql.params, 'all').then(({ rows }) => rows) as Promise<T[]>;
+	}
+
+	override async transaction<T>(
+		_transaction: (tx: MySqlProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_config?: MySqlTransactionConfig,
+	): Promise<T> {
+		throw new Error('Transactions are not supported by the MySql Proxy driver');
+	}
+}
+
+export class MySqlProxyTransaction<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends TablesRelationalConfig,
+> extends MySqlTransaction<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT, TFullSchema, TSchema> {
+	static readonly [entityKind]: string = 'MySqlProxyTransaction';
+
+	override async transaction<T>(
+		_transaction: (tx: MySqlProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+	): Promise<T> {
+		throw new Error('Transactions are not supported by the MySql Proxy driver');
+	}
+}
+
+export class PreparedQuery<T extends PreparedQueryConfig> extends PreparedQueryBase<T> {
+	static readonly [entityKind]: string = 'MySqlProxyPreparedQuery';
+
+	constructor(
+		private client: RemoteCallback,
+		private queryString: string,
+		private params: unknown[],
+		private logger: Logger,
+		private fields: SelectedFieldsOrdered | undefined,
+		private customResultMapper?: (rows: unknown[][]) => T['execute'],
+	) {
+		super();
+	}
+
+	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
+		const params = fillPlaceholders(this.params, placeholderValues);
+
+		const { fields, client, queryString, logger, joinsNotNullableMap, customResultMapper } = this;
+
+		logger.logQuery(queryString, params);
+
+		if (!fields && !customResultMapper) {
+			const { rows } = await client(queryString, params, 'execute');
+
+			return rows;
+		}
+
+		const { rows } = await client(queryString, params, 'all');
+
+		if (customResultMapper) {
+			return customResultMapper(rows);
+		}
+
+		return rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
+	}
+
+	override iterator(
+		_placeholderValues: Record<string, unknown> = {},
+	): AsyncGenerator<T['iterator']> {
+		throw new Error('Streaming is not supported by the MySql Proxy driver');
+	}
+}
+
+export interface MySqlRemoteQueryResultHKT extends QueryResultHKT {
+	type: MySqlRawQueryResult;
+}
+
+export interface MySqlRemotePreparedQueryHKT extends PreparedQueryHKT {
+	type: PreparedQuery<Assume<this['config'], PreparedQueryConfig>>;
+}
diff --git a/drizzle-orm/src/pg-proxy/driver.ts b/drizzle-orm/src/pg-proxy/driver.ts
new file mode 100644
index 000000000..76ae60b0a
--- /dev/null
+++ b/drizzle-orm/src/pg-proxy/driver.ts
@@ -0,0 +1,50 @@
+import { DefaultLogger } from '~/logger.ts';
+import { PgDatabase } from '~/pg-core/db.ts';
+import { PgDialect } from '~/pg-core/dialect.ts';
+import {
+	createTableRelationsHelpers,
+	extractTablesRelationalConfig,
+	type RelationalSchemaConfig,
+	type TablesRelationalConfig,
+} from '~/relations.ts';
+import { type DrizzleConfig } from '~/utils.ts';
+import { PgRemoteSession, type PgRemoteQueryResultHKT } from './session.ts';
+
+export type PgRemoteDatabase<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+> = PgDatabase<PgRemoteQueryResultHKT, TSchema>;
+
+export type RemoteCallback = (
+	sql: string,
+	params: any[],
+	method: 'all' | 'execute'
+) => Promise<{ rows: any[] }>;
+
+export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
+	callback: RemoteCallback,
+	config: DrizzleConfig<TSchema> = {},
+): PgRemoteDatabase<TSchema> {
+	const dialect = new PgDialect();
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
+	if (config.schema) {
+		const tablesConfig = extractTablesRelationalConfig(
+			config.schema,
+			createTableRelationsHelpers,
+		);
+		schema = {
+			fullSchema: config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap,
+		};
+	}
+
+	const session = new PgRemoteSession(callback, dialect, schema, { logger });
+	return new PgDatabase(dialect, session, schema) as PgRemoteDatabase<TSchema>;
+}
diff --git a/drizzle-orm/src/pg-proxy/index.ts b/drizzle-orm/src/pg-proxy/index.ts
new file mode 100644
index 000000000..b1b6a52e7
--- /dev/null
+++ b/drizzle-orm/src/pg-proxy/index.ts
@@ -0,0 +1,2 @@
+export * from './driver.ts';
+export * from './session.ts';
diff --git a/drizzle-orm/src/pg-proxy/migrator.ts b/drizzle-orm/src/pg-proxy/migrator.ts
new file mode 100644
index 000000000..d1519de84
--- /dev/null
+++ b/drizzle-orm/src/pg-proxy/migrator.ts
@@ -0,0 +1,47 @@
+import type { MigrationConfig } from '~/migrator.ts';
+import { readMigrationFiles } from '~/migrator.ts';
+import { sql } from '~/sql/index.ts';
+import type { PgRemoteDatabase } from './driver.ts';
+
+export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
+
+export async function migrate<TSchema extends Record<string, unknown>>(
+	db: PgRemoteDatabase<TSchema>,
+	callback: ProxyMigrator,
+	config: string | MigrationConfig,
+) {
+	const migrations = readMigrationFiles(config);
+	
+	const migrationTableCreate = sql`
+		CREATE TABLE IF NOT EXISTS "drizzle"."__drizzle_migrations" (
+			id SERIAL PRIMARY KEY,
+			hash text NOT NULL,
+			created_at numeric
+		)
+	`;
+
+	await db.execute(sql`CREATE SCHEMA IF NOT EXISTS "drizzle"`);
+	await db.execute(migrationTableCreate);
+
+	const dbMigrations = await db.execute(
+		sql`SELECT id, hash, created_at FROM "drizzle"."__drizzle_migrations" ORDER BY created_at DESC LIMIT 1`
+	) as unknown as [number, string, string][];
+
+	const lastDbMigration = dbMigrations[0] ?? undefined;
+
+	const queriesToRun: string[] = [];
+
+	for (const migration of migrations) {
+		if (
+			!lastDbMigration
+			|| Number(lastDbMigration[2])! < migration.folderMillis
+		) {
+			queriesToRun.push(
+				...migration.sql,
+				`INSERT INTO "drizzle"."__drizzle_migrations" ("hash", "created_at") VALUES('${migration.hash}', '${migration.folderMillis}')`,
+			);
+		}
+	}
+
+	await callback(queriesToRun);
+}
diff --git a/drizzle-orm/src/pg-proxy/session.ts b/drizzle-orm/src/pg-proxy/session.ts
new file mode 100644
index 000000000..ce9f545aa
--- /dev/null
+++ b/drizzle-orm/src/pg-proxy/session.ts
@@ -0,0 +1,127 @@
+import { entityKind } from '~/entity.ts';
+import type { Logger } from '~/logger.ts';
+import { NoopLogger } from '~/logger.ts';
+import type { PgDialect } from '~/pg-core/dialect.ts';
+import { PgTransaction } from '~/pg-core/index.ts';
+import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
+import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
+import { PgSession, PreparedQuery as PreparedQueryBase } from '~/pg-core/session.ts';
+import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import { fillPlaceholders, type Query } from '~/sql/index.ts';
+import { tracer } from '~/tracing.ts';
+import { mapResultRow, type Assume } from '~/utils.ts';
+import { type RemoteCallback } from './driver.ts';
+
+export interface PgRemoteSessionOptions {
+	logger?: Logger;
+}
+
+export class PgRemoteSession<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends TablesRelationalConfig,
+> extends PgSession<PgRemoteQueryResultHKT, TFullSchema, TSchema> {
+	static readonly [entityKind]: string = 'PgRemoteSession';
+
+	private logger: Logger;
+
+	constructor(
+		private client: RemoteCallback,
+		dialect: PgDialect,
+		private schema: RelationalSchemaConfig<TSchema> | undefined,
+		options: PgRemoteSessionOptions = {},
+	) {
+		super(dialect);
+		this.logger = options.logger ?? new NoopLogger();
+	}
+
+	prepareQuery<T extends PreparedQueryConfig>(
+		query: Query,
+		fields: SelectedFieldsOrdered | undefined,
+		name: string | undefined,
+		customResultMapper?: (rows: unknown[][]) => T['execute'],
+	): PreparedQuery<T> {
+		return new PreparedQuery(this.client, query.sql, query.params, this.logger, fields, customResultMapper);
+	}
+
+	override async transaction<T>(
+		_transaction: (tx: PgProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+		_config?: PgTransactionConfig,
+	): Promise<T> {
+		throw new Error('Transactions are not supported by the Postgres Proxy driver');
+	}
+}
+
+export class PgProxyTransaction<
+	TFullSchema extends Record<string, unknown>,
+	TSchema extends TablesRelationalConfig,
+> extends PgTransaction<PgRemoteQueryResultHKT, TFullSchema, TSchema> {
+	static readonly [entityKind]: string = 'PgProxyTransaction';
+
+	override async transaction<T>(
+		_transaction: (tx: PgProxyTransaction<TFullSchema, TSchema>) => Promise<T>,
+	): Promise<T> {
+		throw new Error('Transactions are not supported by the Postgres Proxy driver');
+	}
+}
+
+export class PreparedQuery<T extends PreparedQueryConfig> extends PreparedQueryBase<T> {
+	static readonly [entityKind]: string = 'PgProxyPreparedQuery';
+
+	constructor(
+		private client: RemoteCallback,
+		private queryString: string,
+		private params: unknown[],
+		private logger: Logger,
+		private fields: SelectedFieldsOrdered | undefined,
+		private customResultMapper?: (rows: unknown[][]) => T['execute'],
+	) {
+		super();
+	}
+
+	async execute(placeholderValues: Record<string, unknown> | undefined = {}): Promise<T['execute']> {
+		return tracer.startActiveSpan('drizzle.execute', async (span) => {
+			const params = fillPlaceholders(this.params, placeholderValues);
+			const { fields, client, queryString, joinsNotNullableMap, customResultMapper, logger } = this;
+
+			span?.setAttributes({
+				'drizzle.query.text': queryString,
+				'drizzle.query.params': JSON.stringify(params),
+			});
+
+			logger.logQuery(queryString, params);
+
+			if (!fields && !customResultMapper) {
+				return tracer.startActiveSpan('drizzle.driver.execute', async () => {
+					const { rows } = await client(queryString, params as any[], 'execute');
+
+					return rows;
+				});
+			}
+
+			const rows = await tracer.startActiveSpan('drizzle.driver.execute', async () => {
+				span?.setAttributes({
+					'drizzle.query.text': queryString,
+					'drizzle.query.params': JSON.stringify(params),
+				});
+
+				const { rows } = await client(queryString, params as any[], 'all');
+
+				return rows;
+			});
+
+			return tracer.startActiveSpan('drizzle.mapResponse', () => {
+				return customResultMapper
+					? customResultMapper(rows)
+					: rows.map((row) => mapResultRow<T['execute']>(fields!, row, joinsNotNullableMap));
+			});
+		});
+	}
+
+	async all() {}
+}
+
+export interface PgRemoteQueryResultHKT extends QueryResultHKT {
+	type: Assume<this['row'], {
+		[column: string]: any;
+	}>[];
+}
diff --git a/examples/mysql-proxy/.gitignore b/examples/mysql-proxy/.gitignore
new file mode 100644
index 000000000..55371e5c8
--- /dev/null
+++ b/examples/mysql-proxy/.gitignore
@@ -0,0 +1,2 @@
+node_modules
+.vscode
\ No newline at end of file
diff --git a/examples/mysql-proxy/README.md b/examples/mysql-proxy/README.md
new file mode 100644
index 000000000..8bbdf3f7b
--- /dev/null
+++ b/examples/mysql-proxy/README.md
@@ -0,0 +1,178 @@
+Example project for [Drizzle ORM MySQL Proxy package](https://github.com/drizzle-team/drizzle-orm/tree/main/drizzle-orm/src/mysql-proxy)
+
+Subscribe to our updates on [Twitter](https://twitter.com/DrizzleOrm) and [Discord](https://discord.gg/MdXYZk5QtH)
+
+---
+
+**MySQL Proxy Driver** was designed to easily define custom drivers, https clients, rpc and much more. No need to wait until Drizzle ORM will create support for specific drivers you need. Just create it yourself! 🚀
+
+MySQL Proxy driver will do all the work except of 2 things, that you will be responsible for:
+
+1. Calls to database, http servers or any other way to communicate with database
+2. Mapping data from database to `{rows: any[], ...additional db response params}` format. Only `rows` field is required. Rows should be a row array from database for `all` method and a objects for `execute`
+
+</br>
+This project has simple example of defining http proxy server, that will proxy all calls from drizzle orm to database and back. This example could perfectly fit for serverless applications
+
+---
+
+## Project structure
+
+1. `schema.ts` - drizzle orm schema file
+2. `index.ts` - basic script, that uses drizzle orm pg proxy driver to define logic for server to server communication over http
+3. `server.ts` - server implementation example
+
+### Database calls
+
+---
+
+#### All you need to do - is to setup drizzle database instance with http call implementation
+
+</br>
+
+> **Warning**:
+> You will be responsible for proper error handling in this part. Drizzle always waits for `{rows: string[][] | object[]}` so if any error was on http call(or any other call) - be sure, that you return at least empty array back
+>
+> For `all` method you should return `{rows: string[][]}`
+> For `execute` method you should return `{rows: object[]}`
+
+</br>
+
+```typescript
+import axios from 'axios';
+import { drizzle } from 'drizzle-orm/mysql-proxy';
+
+const db = drizzle(async (sql, params, method) => {
+  try {
+    const rows = await axios.post('http://localhost:3000/query', {
+      sql,
+      params,
+      method,
+    });
+
+    return { rows: rows.data };
+  } catch (e: any) {
+    console.error('Error from mysql proxy server: ', e.response.data);
+    return { rows: [] };
+  }
+});
+```
+
+We have 3 params, that will be sent to server. It's your decision which of them and in which way should be used
+
+1. `sql` - SQL query (`SELECT * FROM users WHERE id = ?`)
+2. `params` - params, that should be sent on database call (For query above it could be: `[1]`)
+3. `method` - Method, that was executed (`all` | `execute`). Hint for proxy server on which pg method to invoke
+
+### Migrations using MySQL Proxy
+
+---
+
+In current MySQL Proxy version - drizzle don't handle transactions for migrations. As for now we are sending an array of queries, that should be executed by user and user should do `commit` or `rollback` logic
+
+</br>
+
+> **Warning**:
+> You will be responsible for proper error handling in this part. Drizzle just finds migrations, that need to be executed on this iteration and if finds some -> provide `queries` array to callback
+
+</br>
+
+```typescript
+import axios from 'axios';
+import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
+
+await migrate(db, async (queries) => {
+  try {
+    await axios.post('http://localhost:3000/migrate', { queries });
+  } catch (e) {
+    console.log(e);
+    throw Error('Proxy server cannot run migrations');
+  }
+}, { migrationsFolder: 'drizzle' });
+```
+
+1. `queries` - array of sql statements, that should be run on migration
+
+### Proxy Server implementation example
+
+---
+
+> **Note**:
+> It's just a suggestion on how proxy server could be set up and a simple example of params handling on `query` and `migration` calls
+
+```typescript
+import * as mysql from 'mysql2/promise';
+import express from 'express';
+
+const app = express();
+app.use(express.json());
+const port = 3000;
+
+const main = async () => {
+const connection = await mysql.createConnection('mysql://root:mysql@127.0.0.1:5432/drizzle');
+
+app.post('/query', async (req, res) => {
+	const { sql: sqlBody, params, method } = req.body;
+
+	if (method === 'all') {
+		try {
+            const result = await connection.query({
+                sql: sqlBody,
+                values: params,
+                rowsAsArray: true,
+                typeCast: function(field: any, next: any) {
+                    if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                        return field.string();
+                    }
+                    return next();
+                },
+            });
+			res.send(result[0]);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else if (method === 'execute') {
+		try {
+            const result = await connection.query({
+                sql: sqlBody,
+                values: params,
+                typeCast: function(field: any, next: any) {
+                    if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                        return field.string();
+                    }
+                    return next();
+                },
+            });
+
+			res.send(result);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else {
+		res.status(500).json({ error: 'Unknown method value' });
+	}
+});
+
+app.post('/migrate', async (req, res) => {
+	const { queries } = req.body;
+
+    await connection.query('BEGIN');
+    try {
+        for (const query of queries) {
+            await connection.query(query);
+        }
+        await connection.query('COMMIT');
+    } catch {
+        await connection.query('ROLLBACK');
+    }
+
+	res.send({});
+});
+
+app.listen(port, () => {
+	console.log(`Example app listening on port ${port}`);
+});
+}
+
+main();
+```
diff --git a/examples/mysql-proxy/drizzle/0000_ambiguous_marvel_boy.sql b/examples/mysql-proxy/drizzle/0000_ambiguous_marvel_boy.sql
new file mode 100644
index 000000000..284afd483
--- /dev/null
+++ b/examples/mysql-proxy/drizzle/0000_ambiguous_marvel_boy.sql
@@ -0,0 +1,15 @@
+CREATE TABLE `cities` (
+	`id` serial AUTO_INCREMENT NOT NULL,
+	`name` text NOT NULL,
+	CONSTRAINT `cities_id` PRIMARY KEY(`id`)
+);
+--> statement-breakpoint
+CREATE TABLE `users` (
+	`id` serial AUTO_INCREMENT NOT NULL,
+	`name` text NOT NULL,
+	`email` text NOT NULL,
+	`city_id` serial AUTO_INCREMENT,
+	CONSTRAINT `users_id` PRIMARY KEY(`id`)
+);
+--> statement-breakpoint
+ALTER TABLE `users` ADD CONSTRAINT `users_city_id_cities_id_fk` FOREIGN KEY (`city_id`) REFERENCES `cities`(`id`) ON DELETE no action ON UPDATE no action;
\ No newline at end of file
diff --git a/examples/mysql-proxy/drizzle/meta/0000_snapshot.json b/examples/mysql-proxy/drizzle/meta/0000_snapshot.json
new file mode 100644
index 000000000..a8aea1038
--- /dev/null
+++ b/examples/mysql-proxy/drizzle/meta/0000_snapshot.json
@@ -0,0 +1,102 @@
+{
+  "version": "5",
+  "dialect": "mysql",
+  "id": "0859c898-548b-4943-a451-24aee7831a25",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "cities": {
+      "name": "cities",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "cities_id": {
+          "name": "cities_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {}
+    },
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "city_id": {
+          "name": "city_id",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "users_city_id_cities_id_fk": {
+          "name": "users_city_id_cities_id_fk",
+          "tableFrom": "users",
+          "tableTo": "cities",
+          "columnsFrom": [
+            "city_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "users_id": {
+          "name": "users_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {}
+    }
+  },
+  "schemas": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  }
+}
\ No newline at end of file
diff --git a/examples/mysql-proxy/drizzle/meta/_journal.json b/examples/mysql-proxy/drizzle/meta/_journal.json
new file mode 100644
index 000000000..dd519472e
--- /dev/null
+++ b/examples/mysql-proxy/drizzle/meta/_journal.json
@@ -0,0 +1,13 @@
+{
+  "version": "5",
+  "dialect": "mysql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "5",
+      "when": 1696232477893,
+      "tag": "0000_ambiguous_marvel_boy",
+      "breakpoints": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/examples/mysql-proxy/package-lock.json b/examples/mysql-proxy/package-lock.json
new file mode 100644
index 000000000..78c4c413d
--- /dev/null
+++ b/examples/mysql-proxy/package-lock.json
@@ -0,0 +1,1796 @@
+{
+  "name": "mysql-proxy",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "mysql-proxy",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "axios": "^1.5.1",
+        "express": "^4.18.2",
+        "mysql2": "^3.6.1"
+      },
+      "devDependencies": {
+        "@types/express": "^4.17.18",
+        "drizzle-kit": "^0.19.13",
+        "tsx": "^3.13.0",
+        "typescript": "^5.2.2"
+      }
+    },
+    "node_modules/@drizzle-team/studio": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/@drizzle-team/studio/-/studio-0.0.5.tgz",
+      "integrity": "sha512-ps5qF0tMxWRVu+V5gvCRrQNqlY92aTnIKdq27gm9LZMSdaKYZt6AVvSK1dlUMzs6Rt0Jm80b+eWct6xShBKhIw==",
+      "dev": true
+    },
+    "node_modules/@esbuild-kit/core-utils": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/@esbuild-kit/core-utils/-/core-utils-3.3.2.tgz",
+      "integrity": "sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==",
+      "dev": true,
+      "dependencies": {
+        "esbuild": "~0.18.20",
+        "source-map-support": "^0.5.21"
+      }
+    },
+    "node_modules/@esbuild-kit/esm-loader": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/@esbuild-kit/esm-loader/-/esm-loader-2.6.5.tgz",
+      "integrity": "sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA==",
+      "dev": true,
+      "dependencies": {
+        "@esbuild-kit/core-utils": "^3.3.2",
+        "get-tsconfig": "^4.7.0"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz",
+      "integrity": "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz",
+      "integrity": "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.20.tgz",
+      "integrity": "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz",
+      "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz",
+      "integrity": "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz",
+      "integrity": "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz",
+      "integrity": "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz",
+      "integrity": "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz",
+      "integrity": "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz",
+      "integrity": "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz",
+      "integrity": "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz",
+      "integrity": "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz",
+      "integrity": "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz",
+      "integrity": "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz",
+      "integrity": "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz",
+      "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz",
+      "integrity": "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz",
+      "integrity": "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz",
+      "integrity": "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz",
+      "integrity": "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz",
+      "integrity": "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz",
+      "integrity": "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@types/body-parser": {
+      "version": "1.19.3",
+      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.3.tgz",
+      "integrity": "sha512-oyl4jvAfTGX9Bt6Or4H9ni1Z447/tQuxnZsytsCaExKlmJiU8sFgnIBRzJUpKwB5eWn9HuBYlUlVA74q/yN0eQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/connect": {
+      "version": "3.4.36",
+      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.36.tgz",
+      "integrity": "sha512-P63Zd/JUGq+PdrM1lv0Wv5SBYeA2+CORvbrXbngriYY0jzLUWfQMQQxOhjONEz/wlHOAxOdY7CY65rgQdTjq2w==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/express": {
+      "version": "4.17.18",
+      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.18.tgz",
+      "integrity": "sha512-Sxv8BSLLgsBYmcnGdGjjEjqET2U+AKAdCRODmMiq02FgjwuV75Ut85DRpvFjyw/Mk0vgUOliGRU0UUmuuZHByQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "*"
+      }
+    },
+    "node_modules/@types/express-serve-static-core": {
+      "version": "4.17.37",
+      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.17.37.tgz",
+      "integrity": "sha512-ZohaCYTgGFcOP7u6aJOhY9uIZQgZ2vxC2yWoArY+FeDXlqeH66ZVBjgvg+RLVAS/DWNq4Ap9ZXu1+SUQiiWYMg==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+      }
+    },
+    "node_modules/@types/http-errors": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.2.tgz",
+      "integrity": "sha512-lPG6KlZs88gef6aD85z3HNkztpj7w2R7HmR3gygjfXCQmsLloWNARFkMuzKiiY8FGdh1XDpgBdrSf4aKDiA7Kg==",
+      "dev": true
+    },
+    "node_modules/@types/mime": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.3.tgz",
+      "integrity": "sha512-Ys+/St+2VF4+xuY6+kDIXGxbNRO0mesVg0bbxEfB97Od1Vjpjx9KD1qxs64Gcb3CWPirk9Xe+PT4YiiHQ9T+eg==",
+      "dev": true
+    },
+    "node_modules/@types/node": {
+      "version": "20.8.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.8.0.tgz",
+      "integrity": "sha512-LzcWltT83s1bthcvjBmiBvGJiiUe84NWRHkw+ZV6Fr41z2FbIzvc815dk2nQ3RAKMuN2fkenM/z3Xv2QzEpYxQ==",
+      "dev": true
+    },
+    "node_modules/@types/qs": {
+      "version": "6.9.8",
+      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.8.tgz",
+      "integrity": "sha512-u95svzDlTysU5xecFNTgfFG5RUWu1A9P0VzgpcIiGZA9iraHOdSzcxMxQ55DyeRaGCSxQi7LxXDI4rzq/MYfdg==",
+      "dev": true
+    },
+    "node_modules/@types/range-parser": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.5.tgz",
+      "integrity": "sha512-xrO9OoVPqFuYyR/loIHjnbvvyRZREYKLjxV4+dY6v3FQR3stQ9ZxIGkaclF7YhI9hfjpuTbu14hZEy94qKLtOA==",
+      "dev": true
+    },
+    "node_modules/@types/send": {
+      "version": "0.17.2",
+      "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.2.tgz",
+      "integrity": "sha512-aAG6yRf6r0wQ29bkS+x97BIs64ZLxeE/ARwyS6wrldMm3C1MdKwCcnnEwMC1slI8wuxJOpiUH9MioC0A0i+GJw==",
+      "dev": true,
+      "dependencies": {
+        "@types/mime": "^1",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/serve-static": {
+      "version": "1.15.3",
+      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.3.tgz",
+      "integrity": "sha512-yVRvFsEMrv7s0lGhzrggJjNOSmZCdgCjw9xWrPr/kNNLp6FaDfMC1KaYl3TSJ0c58bECwNBMoQrZJ8hA8E1eFg==",
+      "dev": true,
+      "dependencies": {
+        "@types/http-errors": "*",
+        "@types/mime": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "node_modules/axios": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.5.1.tgz",
+      "integrity": "sha512-Q28iYCWzNHjAm+yEAot5QaAMxhMghWLFVf7rRdwhUI+c2jix2DUXjAHXVi+s1ibs3mjPO/cCgbA++3BjD0vP/A==",
+      "dependencies": {
+        "follow-redirects": "^1.15.0",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz",
+      "integrity": "sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.4",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.11.0",
+        "raw-body": "2.5.1",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
+      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-7.0.1.tgz",
+      "integrity": "sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==",
+      "dev": true,
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
+      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+      "dev": true,
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/cli-color": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/cli-color/-/cli-color-2.0.3.tgz",
+      "integrity": "sha512-OkoZnxyC4ERN3zLzZaY9Emb7f/MhBOIpePv0Ycok0fJYT+Ouo00UBEIwsVsr0yoow++n5YWlSUgST9GKhNHiRQ==",
+      "dev": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.61",
+        "es6-iterator": "^2.0.3",
+        "memoizee": "^0.4.15",
+        "timers-ext": "^0.1.7"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/commander": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+      "dev": true,
+      "engines": {
+        "node": "^12.20.0 || >=14"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz",
+      "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ=="
+    },
+    "node_modules/d": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz",
+      "integrity": "sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==",
+      "dev": true,
+      "dependencies": {
+        "es5-ext": "^0.10.50",
+        "type": "^1.0.1"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/denque": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
+      "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/difflib": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/difflib/-/difflib-0.2.4.tgz",
+      "integrity": "sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==",
+      "dev": true,
+      "dependencies": {
+        "heap": ">= 0.2.0"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/dreamopt": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/dreamopt/-/dreamopt-0.8.0.tgz",
+      "integrity": "sha512-vyJTp8+mC+G+5dfgsY+r3ckxlz+QMX40VjPQsZc5gxVAxLmi64TBoVkP54A/pRAXMXsbu2GMMBrZPxNv23waMg==",
+      "dev": true,
+      "dependencies": {
+        "wordwrap": ">=0.0.2"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/drizzle-kit": {
+      "version": "0.19.13",
+      "resolved": "https://registry.npmjs.org/drizzle-kit/-/drizzle-kit-0.19.13.tgz",
+      "integrity": "sha512-Rba5VW1O2JfJlwVBeZ8Zwt2E2us5oZ08PQBDiVSGlug53TOc8hzXjblZFuF+dnll9/RQEHrkzBmJFgqTvn5Rxg==",
+      "dev": true,
+      "dependencies": {
+        "@drizzle-team/studio": "^0.0.5",
+        "@esbuild-kit/esm-loader": "^2.5.5",
+        "camelcase": "^7.0.1",
+        "chalk": "^5.2.0",
+        "commander": "^9.4.1",
+        "esbuild": "^0.18.6",
+        "esbuild-register": "^3.4.2",
+        "glob": "^8.1.0",
+        "hanji": "^0.0.5",
+        "json-diff": "0.9.0",
+        "minimatch": "^7.4.3",
+        "zod": "^3.20.2"
+      },
+      "bin": {
+        "drizzle-kit": "index.cjs"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
+    },
+    "node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es5-ext": {
+      "version": "0.10.62",
+      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.62.tgz",
+      "integrity": "sha512-BHLqn0klhEpnOKSrzn/Xsz2UIW8j+cGmo9JLzr8BiUapV8hPL9+FliFqjwr9ngW7jWdnxv6eO+/LqyhJVqgrjA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "dependencies": {
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.3",
+        "next-tick": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/es6-iterator": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz",
+      "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==",
+      "dev": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.35",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/es6-symbol": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.3.tgz",
+      "integrity": "sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==",
+      "dev": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "ext": "^1.1.2"
+      }
+    },
+    "node_modules/es6-weak-map": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz",
+      "integrity": "sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==",
+      "dev": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.46",
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz",
+      "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/android-arm": "0.18.20",
+        "@esbuild/android-arm64": "0.18.20",
+        "@esbuild/android-x64": "0.18.20",
+        "@esbuild/darwin-arm64": "0.18.20",
+        "@esbuild/darwin-x64": "0.18.20",
+        "@esbuild/freebsd-arm64": "0.18.20",
+        "@esbuild/freebsd-x64": "0.18.20",
+        "@esbuild/linux-arm": "0.18.20",
+        "@esbuild/linux-arm64": "0.18.20",
+        "@esbuild/linux-ia32": "0.18.20",
+        "@esbuild/linux-loong64": "0.18.20",
+        "@esbuild/linux-mips64el": "0.18.20",
+        "@esbuild/linux-ppc64": "0.18.20",
+        "@esbuild/linux-riscv64": "0.18.20",
+        "@esbuild/linux-s390x": "0.18.20",
+        "@esbuild/linux-x64": "0.18.20",
+        "@esbuild/netbsd-x64": "0.18.20",
+        "@esbuild/openbsd-x64": "0.18.20",
+        "@esbuild/sunos-x64": "0.18.20",
+        "@esbuild/win32-arm64": "0.18.20",
+        "@esbuild/win32-ia32": "0.18.20",
+        "@esbuild/win32-x64": "0.18.20"
+      }
+    },
+    "node_modules/esbuild-register": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/esbuild-register/-/esbuild-register-3.5.0.tgz",
+      "integrity": "sha512-+4G/XmakeBAsvJuDugJvtyF1x+XJT4FMocynNpxrvEBViirpfUn2PgNpCHedfWhF4WokNsO/OvMKrmJOIJsI5A==",
+      "dev": true,
+      "dependencies": {
+        "debug": "^4.3.4"
+      },
+      "peerDependencies": {
+        "esbuild": ">=0.12 <1"
+      }
+    },
+    "node_modules/esbuild-register/node_modules/debug": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
+      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "dev": true,
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/esbuild-register/node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/event-emitter": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz",
+      "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==",
+      "dev": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "~0.10.14"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.18.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz",
+      "integrity": "sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.1",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.5.0",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.2.0",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.1",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.7",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.11.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.18.0",
+        "serve-static": "1.15.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      }
+    },
+    "node_modules/ext": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
+      "dev": true,
+      "dependencies": {
+        "type": "^2.7.2"
+      }
+    },
+    "node_modules/ext/node_modules/type": {
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/type/-/type-2.7.2.tgz",
+      "integrity": "sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==",
+      "dev": true
+    },
+    "node_modules/finalhandler": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
+      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.3",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.3.tgz",
+      "integrity": "sha512-1VzOtuEM8pC9SFU1E+8KfTjZyMztRsgEfwQl44z8A25uy13jSzTj6dyK2Df52iV0vgHCfBwLhDWevLn95w5v6Q==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
+    },
+    "node_modules/generate-function": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/generate-function/-/generate-function-2.3.1.tgz",
+      "integrity": "sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==",
+      "dependencies": {
+        "is-property": "^1.0.2"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz",
+      "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-proto": "^1.0.1",
+        "has-symbols": "^1.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.7.2",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.7.2.tgz",
+      "integrity": "sha512-wuMsz4leaj5hbGgg4IvDU0bqJagpftG5l5cXIAvo8uZrqn0NJqwtfupTN00VnkQJPcIRrxYrm1Ue24btpCha2A==",
+      "dev": true,
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/hanji": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/hanji/-/hanji-0.0.5.tgz",
+      "integrity": "sha512-Abxw1Lq+TnYiL4BueXqMau222fPSPMFtya8HdpWsz/xVAhifXou71mPh/kY2+08RgFcVccjG3uZHs6K5HAe3zw==",
+      "dev": true,
+      "dependencies": {
+        "lodash.throttle": "^4.1.1",
+        "sisteransi": "^1.0.5"
+      }
+    },
+    "node_modules/has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dependencies": {
+        "function-bind": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/has-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz",
+      "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/heap": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/heap/-/heap-0.2.7.tgz",
+      "integrity": "sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==",
+      "dev": true
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "dev": true,
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.2.2.tgz",
+      "integrity": "sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ==",
+      "dev": true
+    },
+    "node_modules/is-property": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz",
+      "integrity": "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g=="
+    },
+    "node_modules/json-diff": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/json-diff/-/json-diff-0.9.0.tgz",
+      "integrity": "sha512-cVnggDrVkAAA3OvFfHpFEhOnmcsUpleEKq4d4O8sQWWSH40MBrWstKigVB1kGrgLWzuom+7rRdaCsnBD6VyObQ==",
+      "dev": true,
+      "dependencies": {
+        "cli-color": "^2.0.0",
+        "difflib": "~0.2.1",
+        "dreamopt": "~0.8.0"
+      },
+      "bin": {
+        "json-diff": "bin/json-diff.js"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/lodash.throttle": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.throttle/-/lodash.throttle-4.1.1.tgz",
+      "integrity": "sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==",
+      "dev": true
+    },
+    "node_modules/long": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.2.3.tgz",
+      "integrity": "sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q=="
+    },
+    "node_modules/lru-cache": {
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-8.0.5.tgz",
+      "integrity": "sha512-MhWWlVnuab1RG5/zMRRcVGXZLCXrZTgfwMikgzCegsPnG62yDQo5JnqKkrK4jO5iKqDAZGItAqN5CtKBCBWRUA==",
+      "engines": {
+        "node": ">=16.14"
+      }
+    },
+    "node_modules/lru-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/lru-queue/-/lru-queue-0.1.0.tgz",
+      "integrity": "sha512-BpdYkt9EvGl8OfWHDQPISVpcl5xZthb+XPsbELj5AQXxIC8IriDZIQYjBJPEm5rS420sjZ0TLEzRcq5KdBhYrQ==",
+      "dev": true,
+      "dependencies": {
+        "es5-ext": "~0.10.2"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/memoizee": {
+      "version": "0.4.15",
+      "resolved": "https://registry.npmjs.org/memoizee/-/memoizee-0.4.15.tgz",
+      "integrity": "sha512-UBWmJpLZd5STPm7PMUlOw/TSy972M+z8gcyQ5veOnSDRREz/0bmpyTfKt3/51DhEBqCZQn1udM/5flcSPYhkdQ==",
+      "dev": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.53",
+        "es6-weak-map": "^2.0.3",
+        "event-emitter": "^0.3.5",
+        "is-promise": "^2.2.2",
+        "lru-queue": "^0.1.0",
+        "next-tick": "^1.1.0",
+        "timers-ext": "^0.1.7"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
+      "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w=="
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "7.4.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-7.4.6.tgz",
+      "integrity": "sha512-sBz8G/YjVniEz6lKPNpKxXwazJe4c19fEfV2GDMX6AjFz+MX9uDWIZW8XreVhkFW3fkIdTv/gxWr/Kks5FFAVw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+    },
+    "node_modules/mysql2": {
+      "version": "3.6.1",
+      "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.6.1.tgz",
+      "integrity": "sha512-O7FXjLtNkjcMBpLURwkXIhyVbX9i4lq4nNRCykPNOXfceq94kJ0miagmTEGCZieuO8JtwtXaZ41U6KT4eF9y3g==",
+      "dependencies": {
+        "denque": "^2.1.0",
+        "generate-function": "^2.3.1",
+        "iconv-lite": "^0.6.3",
+        "long": "^5.2.1",
+        "lru-cache": "^8.0.0",
+        "named-placeholders": "^1.1.3",
+        "seq-queue": "^0.0.5",
+        "sqlstring": "^2.3.2"
+      },
+      "engines": {
+        "node": ">= 8.0"
+      }
+    },
+    "node_modules/mysql2/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/named-placeholders": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/named-placeholders/-/named-placeholders-1.1.3.tgz",
+      "integrity": "sha512-eLoBxg6wE/rZkJPhU/xRX1WTpkFEwDJEN96oxFrTsqBdbT5ec295Q+CoHrL9IT0DipqKhmGcaZmwOt8OON5x1w==",
+      "dependencies": {
+        "lru-cache": "^7.14.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/named-placeholders/node_modules/lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/next-tick": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz",
+      "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==",
+      "dev": true
+    },
+    "node_modules/object-inspect": {
+      "version": "1.12.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz",
+      "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
+      "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ=="
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
+    "node_modules/qs": {
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
+      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "dependencies": {
+        "side-channel": "^1.0.4"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz",
+      "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "node_modules/send": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
+      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+    },
+    "node_modules/seq-queue": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/seq-queue/-/seq-queue-0.0.5.tgz",
+      "integrity": "sha512-hr3Wtp/GZIc/6DAGPDcV4/9WoZhjrkXsi5B/07QgX8tsdc6ilr7BFM6PM6rbdAX1kFSDYeZGLipIZZKyQP0O5Q=="
+    },
+    "node_modules/serve-static": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
+      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
+      "dependencies": {
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.18.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "node_modules/side-channel": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
+      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "dependencies": {
+        "call-bind": "^1.0.0",
+        "get-intrinsic": "^1.0.2",
+        "object-inspect": "^1.9.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/sisteransi": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
+      "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==",
+      "dev": true
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/sqlstring": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz",
+      "integrity": "sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/timers-ext": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/timers-ext/-/timers-ext-0.1.7.tgz",
+      "integrity": "sha512-b85NUNzTSdodShTIbky6ZF02e8STtVVfD+fu4aXXShEELpozH+bCpJLYMPZbsABN2wDH7fJpqIoXxJpzbf0NqQ==",
+      "dev": true,
+      "dependencies": {
+        "es5-ext": "~0.10.46",
+        "next-tick": "1"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/tsx": {
+      "version": "3.13.0",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-3.13.0.tgz",
+      "integrity": "sha512-rjmRpTu3as/5fjNq/kOkOtihgLxuIz6pbKdj9xwP4J5jOLkBxw/rjN5ANw+KyrrOXV5uB7HC8+SrrSJxT65y+A==",
+      "dev": true,
+      "dependencies": {
+        "esbuild": "~0.18.20",
+        "get-tsconfig": "^4.7.2",
+        "source-map-support": "^0.5.21"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/type": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/type/-/type-1.2.0.tgz",
+      "integrity": "sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==",
+      "dev": true
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
+      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/wordwrap": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
+      "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==",
+      "dev": true
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true
+    },
+    "node_modules/zod": {
+      "version": "3.22.2",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.22.2.tgz",
+      "integrity": "sha512-wvWkphh5WQsJbVk1tbx1l1Ly4yg+XecD+Mq280uBGt9wa5BKSWf4Mhp6GmrkPixhMxmabYY7RbzlwVP32pbGCg==",
+      "dev": true,
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}
diff --git a/examples/mysql-proxy/package.json b/examples/mysql-proxy/package.json
new file mode 100644
index 000000000..5ca080f85
--- /dev/null
+++ b/examples/mysql-proxy/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "mysql-proxy",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test:types": "tsc --noEmit",
+    "start:script": "tsx src/index.ts",
+    "start:proxy-server": "tsx src/server.ts",
+    "generate": "drizzle-kit generate:mysql --schema src/schema.ts"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.5.1",
+    "express": "^4.18.2",
+    "mysql2": "^3.6.1"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.18",
+    "drizzle-kit": "^0.19.13",
+    "tsx": "^3.13.0",
+    "typescript": "^5.2.2"
+  }
+}
diff --git a/examples/mysql-proxy/src/index.ts b/examples/mysql-proxy/src/index.ts
new file mode 100644
index 000000000..8de2fe337
--- /dev/null
+++ b/examples/mysql-proxy/src/index.ts
@@ -0,0 +1,36 @@
+import axios from 'axios';
+import { eq } from 'drizzle-orm/expressions';
+import { drizzle } from 'drizzle-orm/mysql-proxy';
+import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
+import { cities, users } from './schema';
+
+async function main() {
+	const db = drizzle(async (sql, params, method) => {
+		try {
+			const rows = await axios.post('http://localhost:3000/query', { sql, params, method });
+
+			return { rows: rows.data };
+		} catch (e: any) {
+			console.error('Error from pg proxy server:', e.response.data);
+			return { rows: [] };
+		}
+	});
+
+	await migrate(db, async (queries) => {
+		try {
+			await axios.post('http://localhost:3000/migrate', { queries });
+		} catch (e) {
+			console.log(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: 'drizzle' });
+
+	await db.insert(cities).values({ id: 1, name: 'name' });
+
+	await db.insert(users).values({ id: 1, name: 'name', email: 'email', cityId: 1 });
+
+	const usersToCityResponse = await db.select().from(users).leftJoin(cities, eq(users.cityId, cities.id));
+	console.log('usersToCityResponse:', usersToCityResponse);
+}
+
+main();
diff --git a/examples/mysql-proxy/src/schema.ts b/examples/mysql-proxy/src/schema.ts
new file mode 100644
index 000000000..4c8f58ee3
--- /dev/null
+++ b/examples/mysql-proxy/src/schema.ts
@@ -0,0 +1,13 @@
+import { mysqlTable, serial, text } from "drizzle-orm/mysql-core";
+
+export const users = mysqlTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+	cityId: serial('city_id').references(() => cities.id),
+});
+
+export const cities = mysqlTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
diff --git a/examples/mysql-proxy/src/server.ts b/examples/mysql-proxy/src/server.ts
new file mode 100644
index 000000000..42a7687b2
--- /dev/null
+++ b/examples/mysql-proxy/src/server.ts
@@ -0,0 +1,74 @@
+import * as mysql from 'mysql2/promise';
+import express from 'express';
+
+const app = express();
+app.use(express.json());
+const port = 3000;
+
+const main = async () => {
+const connection = await mysql.createConnection('mysql://root:mysql@127.0.0.1:5432/drizzle');
+
+app.post('/query', async (req, res) => {
+	const { sql: sqlBody, params, method } = req.body;
+
+	if (method === 'all') {
+		try {
+            const result = await connection.query({
+                sql: sqlBody,
+                values: params,
+                rowsAsArray: true,
+                typeCast: function(field: any, next: any) {
+                    if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                        return field.string();
+                    }
+                    return next();
+                },
+            });
+			res.send(result[0]);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else if (method === 'execute') {
+		try {
+            const result = await connection.query({
+                sql: sqlBody,
+                values: params,
+                typeCast: function(field: any, next: any) {
+                    if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                        return field.string();
+                    }
+                    return next();
+                },
+            });
+
+			res.send(result);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else {
+		res.status(500).json({ error: 'Unknown method value' });
+	}
+});
+
+app.post('/migrate', async (req, res) => {
+	const { queries } = req.body;
+
+    await connection.query('BEGIN');
+    try {
+        for (const query of queries) {
+            await connection.query(query);
+        }
+        await connection.query('COMMIT');
+    } catch {
+        await connection.query('ROLLBACK');
+    }
+
+	res.send({});
+});
+
+app.listen(port, () => {
+	console.log(`Example app listening on port ${port}`);
+});
+}
+
+main();
diff --git a/examples/mysql-proxy/tsconfig.json b/examples/mysql-proxy/tsconfig.json
new file mode 100644
index 000000000..453f11f98
--- /dev/null
+++ b/examples/mysql-proxy/tsconfig.json
@@ -0,0 +1,26 @@
+{
+	"compilerOptions": {
+		"target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+		"module": "commonjs" /* Specify what module code is generated. */,
+		"esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+		"forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+		"strict": true /* Enable all strict type-checking options. */,
+		"noImplicitAny": true /* Enable error reporting for expressions and declarations with an implied 'any' type. */,
+		"strictNullChecks": true /* When type checking, take into account 'null' and 'undefined'. */,
+		"strictFunctionTypes": true /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */,
+		"strictBindCallApply": true /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */,
+		"strictPropertyInitialization": true /* Check for class properties that are declared but not set in the constructor. */,
+		"noImplicitThis": true /* Enable error reporting when 'this' is given the type 'any'. */,
+		"useUnknownInCatchVariables": true /* Default catch clause variables as 'unknown' instead of 'any'. */,
+		"alwaysStrict": true /* Ensure 'use strict' is always emitted. */,
+		"noUnusedLocals": true /* Enable error reporting when local variables aren't read. */,
+		"noUnusedParameters": true /* Raise an error when a function parameter isn't read. */,
+		"exactOptionalPropertyTypes": true /* Interpret optional property types as written, rather than adding 'undefined'. */,
+		"noImplicitReturns": true /* Enable error reporting for codepaths that do not explicitly return in a function. */,
+		"noFallthroughCasesInSwitch": true /* Enable error reporting for fallthrough cases in switch statements. */,
+		"noUncheckedIndexedAccess": true /* Add 'undefined' to a type when accessed using an index. */,
+		"noImplicitOverride": true /* Ensure overriding members in derived classes are marked with an override modifier. */,
+		"noPropertyAccessFromIndexSignature": true /* Enforces using indexed accessors for keys declared using an indexed type. */,
+		"skipLibCheck": true /* Skip type checking all .d.ts files. */,
+	}
+}
diff --git a/examples/pg-proxy/.gitignore b/examples/pg-proxy/.gitignore
new file mode 100644
index 000000000..55371e5c8
--- /dev/null
+++ b/examples/pg-proxy/.gitignore
@@ -0,0 +1,2 @@
+node_modules
+.vscode
\ No newline at end of file
diff --git a/examples/pg-proxy/README.md b/examples/pg-proxy/README.md
new file mode 100644
index 000000000..d9ff24fb1
--- /dev/null
+++ b/examples/pg-proxy/README.md
@@ -0,0 +1,162 @@
+Example project for [Drizzle ORM Postgres Proxy package](https://github.com/drizzle-team/drizzle-orm/tree/main/drizzle-orm/src/pg-proxy)
+
+Subscribe to our updates on [Twitter](https://twitter.com/DrizzleOrm) and [Discord](https://discord.gg/MdXYZk5QtH)
+
+---
+
+**Postgres Proxy Driver** was designed to easily define custom drivers, https clients, rpc and much more. No need to wait until Drizzle ORM will create support for specific drivers you need. Just create it yourself! 🚀
+
+Postgres Proxy driver will do all the work except of 2 things, that you will be responsible for:
+
+1. Calls to database, http servers or any other way to communicate with database
+2. Mapping data from database to `{rows: any[], ...additional db response params}` format. Only `rows` field is required. Rows should be a row array from database for `all` method and a objects for `execute`
+
+</br>
+This project has simple example of defining http proxy server, that will proxy all calls from drizzle orm to database and back. This example could perfectly fit for serverless applications
+
+---
+
+## Project structure
+
+1. `schema.ts` - drizzle orm schema file
+2. `index.ts` - basic script, that uses drizzle orm pg proxy driver to define logic for server to server communication over http
+3. `server.ts` - server implementation example
+
+### Database calls
+
+---
+
+#### All you need to do - is to setup drizzle database instance with http call implementation
+
+</br>
+
+> **Warning**:
+> You will be responsible for proper error handling in this part. Drizzle always waits for `{rows: string[][] | object[]}` so if any error was on http call(or any other call) - be sure, that you return at least empty array back
+>
+> For `all` method you should return `{rows: string[][]}`
+> For `execute` method you should return `{rows: object[]}`
+
+</br>
+
+```typescript
+import axios from 'axios';
+import { drizzle } from 'drizzle-orm/pg-proxy';
+
+const db = drizzle(async (sql, params, method) => {
+  try {
+    const rows = await axios.post('http://localhost:3000/query', {
+      sql,
+      params,
+      method,
+    });
+
+    return { rows: rows.data };
+  } catch (e: any) {
+    console.error('Error from pg proxy server: ', e.response.data);
+    return { rows: [] };
+  }
+});
+```
+
+We have 3 params, that will be sent to server. It's your decision which of them and in which way should be used
+
+1. `sql` - SQL query (`SELECT * FROM users WHERE id = ?`)
+2. `params` - params, that should be sent on database call (For query above it could be: `[1]`)
+3. `method` - Method, that was executed (`all` | `execute`). Hint for proxy server on which pg method to invoke
+
+### Migrations using Postgres Proxy
+
+---
+
+In current Postgres Proxy version - drizzle don't handle transactions for migrations. As for now we are sending an array of queries, that should be executed by user and user should do `commit` or `rollback` logic
+
+</br>
+
+> **Warning**:
+> You will be responsible for proper error handling in this part. Drizzle just finds migrations, that need to be executed on this iteration and if finds some -> provide `queries` array to callback
+
+</br>
+
+```typescript
+import axios from 'axios';
+import { migrate } from 'drizzle-orm/pg-proxy/migrator';
+
+await migrate(db, async (queries) => {
+  try {
+    await axios.post('http://localhost:3000/migrate', { queries });
+  } catch (e) {
+    console.log(e);
+    throw Error('Proxy server cannot run migrations');
+  }
+}, { migrationsFolder: 'drizzle' });
+```
+
+1. `queries` - array of sql statements, that should be run on migration
+
+### Proxy Server implementation example
+
+---
+
+> **Note**:
+> It's just a suggestion on how proxy server could be set up and a simple example of params handling on `query` and `migration` calls
+
+```typescript
+import { Client } from 'pg';
+import express from 'express';
+
+const app = express();
+app.use(express.json());
+const port = 3000;
+
+const client = new Client('postgres://postgres:postgres@localhost:5432/postgres');
+
+app.post('/query', async (req, res) => {
+	const { sql: sqlBody, params, method } = req.body;
+
+	if (method === 'all') {
+		try {
+            const result = await client.query({
+                text: sqlBody,
+                values: params,
+                rowMode: 'array',
+            });
+			res.send(result.rows);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else if (method === 'execute') {
+		try {
+            const result = await client.query({
+                text: sqlBody,
+                values: params,
+            });
+
+			res.send(result.rows);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else {
+		res.status(500).json({ error: 'Unknown method value' });
+	}
+});
+
+app.post('/migrate', async (req, res) => {
+	const { queries } = req.body;
+
+    await client.query('BEGIN');
+    try {
+        for (const query of queries) {
+            await client.query(query);
+        }
+        await client.query('COMMIT');
+    } catch {
+        await client.query('ROLLBACK');
+    }
+
+	res.send({});
+});
+
+app.listen(port, () => {
+	console.log(`Example app listening on port ${port}`);
+});
+```
diff --git a/examples/pg-proxy/drizzle/0000_loving_gravity.sql b/examples/pg-proxy/drizzle/0000_loving_gravity.sql
new file mode 100644
index 000000000..00c1f54ca
--- /dev/null
+++ b/examples/pg-proxy/drizzle/0000_loving_gravity.sql
@@ -0,0 +1,17 @@
+CREATE TABLE IF NOT EXISTS "cities" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"name" text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "users" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"name" text NOT NULL,
+	"email" text NOT NULL,
+	"city_id" serial NOT NULL
+);
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "users" ADD CONSTRAINT "users_city_id_cities_id_fk" FOREIGN KEY ("city_id") REFERENCES "cities"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
diff --git a/examples/pg-proxy/drizzle/meta/0000_snapshot.json b/examples/pg-proxy/drizzle/meta/0000_snapshot.json
new file mode 100644
index 000000000..5b95cc690
--- /dev/null
+++ b/examples/pg-proxy/drizzle/meta/0000_snapshot.json
@@ -0,0 +1,85 @@
+{
+  "version": "5",
+  "dialect": "pg",
+  "id": "2d1f89a5-9e67-4d3a-8769-89f5c509df82",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "cities": {
+      "name": "cities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    },
+    "users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "city_id": {
+          "name": "city_id",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "users_city_id_cities_id_fk": {
+          "name": "users_city_id_cities_id_fk",
+          "tableFrom": "users",
+          "tableTo": "cities",
+          "columnsFrom": [
+            "city_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {}
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  }
+}
\ No newline at end of file
diff --git a/examples/pg-proxy/drizzle/meta/_journal.json b/examples/pg-proxy/drizzle/meta/_journal.json
new file mode 100644
index 000000000..f24425954
--- /dev/null
+++ b/examples/pg-proxy/drizzle/meta/_journal.json
@@ -0,0 +1,13 @@
+{
+  "version": "5",
+  "dialect": "pg",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "5",
+      "when": 1696231532854,
+      "tag": "0000_loving_gravity",
+      "breakpoints": true
+    }
+  ]
+}
\ No newline at end of file
diff --git a/examples/pg-proxy/package-lock.json b/examples/pg-proxy/package-lock.json
new file mode 100644
index 000000000..58554f5f9
--- /dev/null
+++ b/examples/pg-proxy/package-lock.json
@@ -0,0 +1,1938 @@
+{
+  "name": "pg-proxy",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "pg-proxy",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "axios": "^1.5.1",
+        "express": "^4.18.2",
+        "pg": "^8.11.3"
+      },
+      "devDependencies": {
+        "@types/express": "^4.17.18",
+        "@types/pg": "^8.10.3",
+        "drizzle-kit": "^0.19.13",
+        "tsx": "^3.13.0",
+        "typescript": "^5.2.2"
+      }
+    },
+    "node_modules/@drizzle-team/studio": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/@drizzle-team/studio/-/studio-0.0.5.tgz",
+      "integrity": "sha512-ps5qF0tMxWRVu+V5gvCRrQNqlY92aTnIKdq27gm9LZMSdaKYZt6AVvSK1dlUMzs6Rt0Jm80b+eWct6xShBKhIw==",
+      "dev": true
+    },
+    "node_modules/@esbuild-kit/core-utils": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/@esbuild-kit/core-utils/-/core-utils-3.3.2.tgz",
+      "integrity": "sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ==",
+      "dev": true,
+      "dependencies": {
+        "esbuild": "~0.18.20",
+        "source-map-support": "^0.5.21"
+      }
+    },
+    "node_modules/@esbuild-kit/esm-loader": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/@esbuild-kit/esm-loader/-/esm-loader-2.6.5.tgz",
+      "integrity": "sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA==",
+      "dev": true,
+      "dependencies": {
+        "@esbuild-kit/core-utils": "^3.3.2",
+        "get-tsconfig": "^4.7.0"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz",
+      "integrity": "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz",
+      "integrity": "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.20.tgz",
+      "integrity": "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz",
+      "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz",
+      "integrity": "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz",
+      "integrity": "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz",
+      "integrity": "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz",
+      "integrity": "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz",
+      "integrity": "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz",
+      "integrity": "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz",
+      "integrity": "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz",
+      "integrity": "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz",
+      "integrity": "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz",
+      "integrity": "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz",
+      "integrity": "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz",
+      "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz",
+      "integrity": "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz",
+      "integrity": "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz",
+      "integrity": "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz",
+      "integrity": "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz",
+      "integrity": "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz",
+      "integrity": "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@types/body-parser": {
+      "version": "1.19.3",
+      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.3.tgz",
+      "integrity": "sha512-oyl4jvAfTGX9Bt6Or4H9ni1Z447/tQuxnZsytsCaExKlmJiU8sFgnIBRzJUpKwB5eWn9HuBYlUlVA74q/yN0eQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/connect": {
+      "version": "3.4.36",
+      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.36.tgz",
+      "integrity": "sha512-P63Zd/JUGq+PdrM1lv0Wv5SBYeA2+CORvbrXbngriYY0jzLUWfQMQQxOhjONEz/wlHOAxOdY7CY65rgQdTjq2w==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/express": {
+      "version": "4.17.18",
+      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.18.tgz",
+      "integrity": "sha512-Sxv8BSLLgsBYmcnGdGjjEjqET2U+AKAdCRODmMiq02FgjwuV75Ut85DRpvFjyw/Mk0vgUOliGRU0UUmuuZHByQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "*"
+      }
+    },
+    "node_modules/@types/express-serve-static-core": {
+      "version": "4.17.37",
+      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.17.37.tgz",
+      "integrity": "sha512-ZohaCYTgGFcOP7u6aJOhY9uIZQgZ2vxC2yWoArY+FeDXlqeH66ZVBjgvg+RLVAS/DWNq4Ap9ZXu1+SUQiiWYMg==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+      }
+    },
+    "node_modules/@types/http-errors": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.2.tgz",
+      "integrity": "sha512-lPG6KlZs88gef6aD85z3HNkztpj7w2R7HmR3gygjfXCQmsLloWNARFkMuzKiiY8FGdh1XDpgBdrSf4aKDiA7Kg==",
+      "dev": true
+    },
+    "node_modules/@types/mime": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.3.tgz",
+      "integrity": "sha512-Ys+/St+2VF4+xuY6+kDIXGxbNRO0mesVg0bbxEfB97Od1Vjpjx9KD1qxs64Gcb3CWPirk9Xe+PT4YiiHQ9T+eg==",
+      "dev": true
+    },
+    "node_modules/@types/node": {
+      "version": "20.8.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.8.0.tgz",
+      "integrity": "sha512-LzcWltT83s1bthcvjBmiBvGJiiUe84NWRHkw+ZV6Fr41z2FbIzvc815dk2nQ3RAKMuN2fkenM/z3Xv2QzEpYxQ==",
+      "dev": true
+    },
+    "node_modules/@types/pg": {
+      "version": "8.10.3",
+      "resolved": "https://registry.npmjs.org/@types/pg/-/pg-8.10.3.tgz",
+      "integrity": "sha512-BACzsw64lCZesclRpZGu55tnqgFAYcrCBP92xLh1KLypZLCOsvJTSTgaoFVTy3lCys/aZTQzfeDxtjwrvdzL2g==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*",
+        "pg-protocol": "*",
+        "pg-types": "^4.0.1"
+      }
+    },
+    "node_modules/@types/pg/node_modules/pg-types": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-4.0.1.tgz",
+      "integrity": "sha512-hRCSDuLII9/LE3smys1hRHcu5QGcLs9ggT7I/TCs0IE+2Eesxi9+9RWAAwZ0yaGjxoWICF/YHLOEjydGujoJ+g==",
+      "dev": true,
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "pg-numeric": "1.0.2",
+        "postgres-array": "~3.0.1",
+        "postgres-bytea": "~3.0.0",
+        "postgres-date": "~2.0.1",
+        "postgres-interval": "^3.0.0",
+        "postgres-range": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@types/pg/node_modules/postgres-array": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-3.0.2.tgz",
+      "integrity": "sha512-6faShkdFugNQCLwucjPcY5ARoW1SlbnrZjmGl0IrrqewpvxvhSLHimCVzqeuULCbG0fQv7Dtk1yDbG3xv7Veog==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@types/pg/node_modules/postgres-bytea": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-3.0.0.tgz",
+      "integrity": "sha512-CNd4jim9RFPkObHSjVHlVrxoVQXz7quwNFpz7RY1okNNme49+sVyiTvTRobiLV548Hx/hb1BG+iE7h9493WzFw==",
+      "dev": true,
+      "dependencies": {
+        "obuf": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/@types/pg/node_modules/postgres-date": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-2.0.1.tgz",
+      "integrity": "sha512-YtMKdsDt5Ojv1wQRvUhnyDJNSr2dGIC96mQVKz7xufp07nfuFONzdaowrMHjlAzY6GDLd4f+LUHHAAM1h4MdUw==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@types/pg/node_modules/postgres-interval": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-3.0.0.tgz",
+      "integrity": "sha512-BSNDnbyZCXSxgA+1f5UU2GmwhoI0aU5yMxRGO8CdFEcY2BQF9xm/7MqKnYoM1nJDk8nONNWDk9WeSmePFhQdlw==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@types/qs": {
+      "version": "6.9.8",
+      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.8.tgz",
+      "integrity": "sha512-u95svzDlTysU5xecFNTgfFG5RUWu1A9P0VzgpcIiGZA9iraHOdSzcxMxQ55DyeRaGCSxQi7LxXDI4rzq/MYfdg==",
+      "dev": true
+    },
+    "node_modules/@types/range-parser": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.5.tgz",
+      "integrity": "sha512-xrO9OoVPqFuYyR/loIHjnbvvyRZREYKLjxV4+dY6v3FQR3stQ9ZxIGkaclF7YhI9hfjpuTbu14hZEy94qKLtOA==",
+      "dev": true
+    },
+    "node_modules/@types/send": {
+      "version": "0.17.2",
+      "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.2.tgz",
+      "integrity": "sha512-aAG6yRf6r0wQ29bkS+x97BIs64ZLxeE/ARwyS6wrldMm3C1MdKwCcnnEwMC1slI8wuxJOpiUH9MioC0A0i+GJw==",
+      "dev": true,
+      "dependencies": {
+        "@types/mime": "^1",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/serve-static": {
+      "version": "1.15.3",
+      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.3.tgz",
+      "integrity": "sha512-yVRvFsEMrv7s0lGhzrggJjNOSmZCdgCjw9xWrPr/kNNLp6FaDfMC1KaYl3TSJ0c58bECwNBMoQrZJ8hA8E1eFg==",
+      "dev": true,
+      "dependencies": {
+        "@types/http-errors": "*",
+        "@types/mime": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "node_modules/axios": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.5.1.tgz",
+      "integrity": "sha512-Q28iYCWzNHjAm+yEAot5QaAMxhMghWLFVf7rRdwhUI+c2jix2DUXjAHXVi+s1ibs3mjPO/cCgbA++3BjD0vP/A==",
+      "dependencies": {
+        "follow-redirects": "^1.15.0",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz",
+      "integrity": "sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.4",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.11.0",
+        "raw-body": "2.5.1",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true
+    },
+    "node_modules/buffer-writer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/buffer-writer/-/buffer-writer-2.0.0.tgz",
+      "integrity": "sha512-a7ZpuTZU1TRtnwyCNW3I5dc0wWNC3VR9S++Ewyk2HHZdrO3CQJqSpd+95Us590V6AL7JqUAH2IwZ/398PmNFgw==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
+      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-7.0.1.tgz",
+      "integrity": "sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==",
+      "dev": true,
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
+      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+      "dev": true,
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/cli-color": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/cli-color/-/cli-color-2.0.3.tgz",
+      "integrity": "sha512-OkoZnxyC4ERN3zLzZaY9Emb7f/MhBOIpePv0Ycok0fJYT+Ouo00UBEIwsVsr0yoow++n5YWlSUgST9GKhNHiRQ==",
+      "dev": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.61",
+        "es6-iterator": "^2.0.3",
+        "memoizee": "^0.4.15",
+        "timers-ext": "^0.1.7"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/commander": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+      "dev": true,
+      "engines": {
+        "node": "^12.20.0 || >=14"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz",
+      "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ=="
+    },
+    "node_modules/d": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz",
+      "integrity": "sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==",
+      "dev": true,
+      "dependencies": {
+        "es5-ext": "^0.10.50",
+        "type": "^1.0.1"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/difflib": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/difflib/-/difflib-0.2.4.tgz",
+      "integrity": "sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==",
+      "dev": true,
+      "dependencies": {
+        "heap": ">= 0.2.0"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/dreamopt": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/dreamopt/-/dreamopt-0.8.0.tgz",
+      "integrity": "sha512-vyJTp8+mC+G+5dfgsY+r3ckxlz+QMX40VjPQsZc5gxVAxLmi64TBoVkP54A/pRAXMXsbu2GMMBrZPxNv23waMg==",
+      "dev": true,
+      "dependencies": {
+        "wordwrap": ">=0.0.2"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/drizzle-kit": {
+      "version": "0.19.13",
+      "resolved": "https://registry.npmjs.org/drizzle-kit/-/drizzle-kit-0.19.13.tgz",
+      "integrity": "sha512-Rba5VW1O2JfJlwVBeZ8Zwt2E2us5oZ08PQBDiVSGlug53TOc8hzXjblZFuF+dnll9/RQEHrkzBmJFgqTvn5Rxg==",
+      "dev": true,
+      "dependencies": {
+        "@drizzle-team/studio": "^0.0.5",
+        "@esbuild-kit/esm-loader": "^2.5.5",
+        "camelcase": "^7.0.1",
+        "chalk": "^5.2.0",
+        "commander": "^9.4.1",
+        "esbuild": "^0.18.6",
+        "esbuild-register": "^3.4.2",
+        "glob": "^8.1.0",
+        "hanji": "^0.0.5",
+        "json-diff": "0.9.0",
+        "minimatch": "^7.4.3",
+        "zod": "^3.20.2"
+      },
+      "bin": {
+        "drizzle-kit": "index.cjs"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="
+    },
+    "node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es5-ext": {
+      "version": "0.10.62",
+      "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.62.tgz",
+      "integrity": "sha512-BHLqn0klhEpnOKSrzn/Xsz2UIW8j+cGmo9JLzr8BiUapV8hPL9+FliFqjwr9ngW7jWdnxv6eO+/LqyhJVqgrjA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "dependencies": {
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.3",
+        "next-tick": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/es6-iterator": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz",
+      "integrity": "sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==",
+      "dev": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.35",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/es6-symbol": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.3.tgz",
+      "integrity": "sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==",
+      "dev": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "ext": "^1.1.2"
+      }
+    },
+    "node_modules/es6-weak-map": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz",
+      "integrity": "sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==",
+      "dev": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "^0.10.46",
+        "es6-iterator": "^2.0.3",
+        "es6-symbol": "^3.1.1"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz",
+      "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/android-arm": "0.18.20",
+        "@esbuild/android-arm64": "0.18.20",
+        "@esbuild/android-x64": "0.18.20",
+        "@esbuild/darwin-arm64": "0.18.20",
+        "@esbuild/darwin-x64": "0.18.20",
+        "@esbuild/freebsd-arm64": "0.18.20",
+        "@esbuild/freebsd-x64": "0.18.20",
+        "@esbuild/linux-arm": "0.18.20",
+        "@esbuild/linux-arm64": "0.18.20",
+        "@esbuild/linux-ia32": "0.18.20",
+        "@esbuild/linux-loong64": "0.18.20",
+        "@esbuild/linux-mips64el": "0.18.20",
+        "@esbuild/linux-ppc64": "0.18.20",
+        "@esbuild/linux-riscv64": "0.18.20",
+        "@esbuild/linux-s390x": "0.18.20",
+        "@esbuild/linux-x64": "0.18.20",
+        "@esbuild/netbsd-x64": "0.18.20",
+        "@esbuild/openbsd-x64": "0.18.20",
+        "@esbuild/sunos-x64": "0.18.20",
+        "@esbuild/win32-arm64": "0.18.20",
+        "@esbuild/win32-ia32": "0.18.20",
+        "@esbuild/win32-x64": "0.18.20"
+      }
+    },
+    "node_modules/esbuild-register": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/esbuild-register/-/esbuild-register-3.5.0.tgz",
+      "integrity": "sha512-+4G/XmakeBAsvJuDugJvtyF1x+XJT4FMocynNpxrvEBViirpfUn2PgNpCHedfWhF4WokNsO/OvMKrmJOIJsI5A==",
+      "dev": true,
+      "dependencies": {
+        "debug": "^4.3.4"
+      },
+      "peerDependencies": {
+        "esbuild": ">=0.12 <1"
+      }
+    },
+    "node_modules/esbuild-register/node_modules/debug": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
+      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "dev": true,
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/esbuild-register/node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/event-emitter": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz",
+      "integrity": "sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==",
+      "dev": true,
+      "dependencies": {
+        "d": "1",
+        "es5-ext": "~0.10.14"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.18.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz",
+      "integrity": "sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.1",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.5.0",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.2.0",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.1",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.7",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.11.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.18.0",
+        "serve-static": "1.15.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      }
+    },
+    "node_modules/ext": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
+      "integrity": "sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==",
+      "dev": true,
+      "dependencies": {
+        "type": "^2.7.2"
+      }
+    },
+    "node_modules/ext/node_modules/type": {
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/type/-/type-2.7.2.tgz",
+      "integrity": "sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==",
+      "dev": true
+    },
+    "node_modules/finalhandler": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
+      "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.3",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.3.tgz",
+      "integrity": "sha512-1VzOtuEM8pC9SFU1E+8KfTjZyMztRsgEfwQl44z8A25uy13jSzTj6dyK2Df52iV0vgHCfBwLhDWevLn95w5v6Q==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz",
+      "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==",
+      "dependencies": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-proto": "^1.0.1",
+        "has-symbols": "^1.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.7.2",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.7.2.tgz",
+      "integrity": "sha512-wuMsz4leaj5hbGgg4IvDU0bqJagpftG5l5cXIAvo8uZrqn0NJqwtfupTN00VnkQJPcIRrxYrm1Ue24btpCha2A==",
+      "dev": true,
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/hanji": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/hanji/-/hanji-0.0.5.tgz",
+      "integrity": "sha512-Abxw1Lq+TnYiL4BueXqMau222fPSPMFtya8HdpWsz/xVAhifXou71mPh/kY2+08RgFcVccjG3uZHs6K5HAe3zw==",
+      "dev": true,
+      "dependencies": {
+        "lodash.throttle": "^4.1.1",
+        "sisteransi": "^1.0.5"
+      }
+    },
+    "node_modules/has": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+      "dependencies": {
+        "function-bind": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/has-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz",
+      "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
+      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/heap": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/heap/-/heap-0.2.7.tgz",
+      "integrity": "sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==",
+      "dev": true
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "dev": true,
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.2.2.tgz",
+      "integrity": "sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ==",
+      "dev": true
+    },
+    "node_modules/json-diff": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/json-diff/-/json-diff-0.9.0.tgz",
+      "integrity": "sha512-cVnggDrVkAAA3OvFfHpFEhOnmcsUpleEKq4d4O8sQWWSH40MBrWstKigVB1kGrgLWzuom+7rRdaCsnBD6VyObQ==",
+      "dev": true,
+      "dependencies": {
+        "cli-color": "^2.0.0",
+        "difflib": "~0.2.1",
+        "dreamopt": "~0.8.0"
+      },
+      "bin": {
+        "json-diff": "bin/json-diff.js"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/lodash.throttle": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.throttle/-/lodash.throttle-4.1.1.tgz",
+      "integrity": "sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==",
+      "dev": true
+    },
+    "node_modules/lru-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/lru-queue/-/lru-queue-0.1.0.tgz",
+      "integrity": "sha512-BpdYkt9EvGl8OfWHDQPISVpcl5xZthb+XPsbELj5AQXxIC8IriDZIQYjBJPEm5rS420sjZ0TLEzRcq5KdBhYrQ==",
+      "dev": true,
+      "dependencies": {
+        "es5-ext": "~0.10.2"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/memoizee": {
+      "version": "0.4.15",
+      "resolved": "https://registry.npmjs.org/memoizee/-/memoizee-0.4.15.tgz",
+      "integrity": "sha512-UBWmJpLZd5STPm7PMUlOw/TSy972M+z8gcyQ5veOnSDRREz/0bmpyTfKt3/51DhEBqCZQn1udM/5flcSPYhkdQ==",
+      "dev": true,
+      "dependencies": {
+        "d": "^1.0.1",
+        "es5-ext": "^0.10.53",
+        "es6-weak-map": "^2.0.3",
+        "event-emitter": "^0.3.5",
+        "is-promise": "^2.2.2",
+        "lru-queue": "^0.1.0",
+        "next-tick": "^1.1.0",
+        "timers-ext": "^0.1.7"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
+      "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w=="
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "7.4.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-7.4.6.tgz",
+      "integrity": "sha512-sBz8G/YjVniEz6lKPNpKxXwazJe4c19fEfV2GDMX6AjFz+MX9uDWIZW8XreVhkFW3fkIdTv/gxWr/Kks5FFAVw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/next-tick": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz",
+      "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==",
+      "dev": true
+    },
+    "node_modules/object-inspect": {
+      "version": "1.12.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz",
+      "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/obuf": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/obuf/-/obuf-1.1.2.tgz",
+      "integrity": "sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==",
+      "dev": true
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/packet-reader": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/packet-reader/-/packet-reader-1.0.0.tgz",
+      "integrity": "sha512-HAKu/fG3HpHFO0AA8WE8q2g+gBJaZ9MG7fcKk+IJPLTGAD6Psw4443l+9DGRbOIh3/aXr7Phy0TjilYivJo5XQ=="
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
+      "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ=="
+    },
+    "node_modules/pg": {
+      "version": "8.11.3",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.11.3.tgz",
+      "integrity": "sha512-+9iuvG8QfaaUrrph+kpF24cXkH1YOOUeArRNYIxq1viYHZagBxrTno7cecY1Fa44tJeZvaoG+Djpkc3JwehN5g==",
+      "dependencies": {
+        "buffer-writer": "2.0.0",
+        "packet-reader": "1.0.0",
+        "pg-connection-string": "^2.6.2",
+        "pg-pool": "^3.6.1",
+        "pg-protocol": "^1.6.0",
+        "pg-types": "^2.1.0",
+        "pgpass": "1.x"
+      },
+      "engines": {
+        "node": ">= 8.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.1.1"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.1.1.tgz",
+      "integrity": "sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q==",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.6.2",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.6.2.tgz",
+      "integrity": "sha512-ch6OwaeaPYcova4kKZ15sbJ2hKb/VP48ZD2gE7i1J+L4MspCtBMAx8nMgz7bksc7IojCIIWuEhHibSMFH8m8oA=="
+    },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-numeric": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/pg-numeric/-/pg-numeric-1.0.2.tgz",
+      "integrity": "sha512-BM/Thnrw5jm2kKLE5uJkXqqExRUY/toLHda65XgFTBTFYZyopbKjBe29Ii3RbkvlsMoFwD+tHeGaCjjv0gHlyw==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.6.1",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.6.1.tgz",
+      "integrity": "sha512-jizsIzhkIitxCGfPRzJn1ZdcosIt3pz9Sh3V01fm1vZnbnCMgmGl5wvGGdNN2EL9Rmb0EcFoCkixH4Pu+sP9Og==",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.6.0.tgz",
+      "integrity": "sha512-M+PDm637OY5WM307051+bsDia5Xej6d9IR4GwJse1qA1DIhiKlksvrneZOYQq42OM+spubpcNYEo2FcKQrDk+Q=="
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
+    "node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz",
+      "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-range": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/postgres-range/-/postgres-range-1.1.3.tgz",
+      "integrity": "sha512-VdlZoocy5lCP0c/t66xAfclglEapXPCIVhqqJRncYpvbCgImF0w67aPKfbqUMr72tO2k5q0TdTZwCLjPTI6C9g==",
+      "dev": true
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
+    "node_modules/qs": {
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
+      "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
+      "dependencies": {
+        "side-channel": "^1.0.4"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz",
+      "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "node_modules/send": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz",
+      "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+    },
+    "node_modules/serve-static": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz",
+      "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==",
+      "dependencies": {
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.18.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="
+    },
+    "node_modules/side-channel": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
+      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "dependencies": {
+        "call-bind": "^1.0.0",
+        "get-intrinsic": "^1.0.2",
+        "object-inspect": "^1.9.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/sisteransi": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
+      "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==",
+      "dev": true
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/timers-ext": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/timers-ext/-/timers-ext-0.1.7.tgz",
+      "integrity": "sha512-b85NUNzTSdodShTIbky6ZF02e8STtVVfD+fu4aXXShEELpozH+bCpJLYMPZbsABN2wDH7fJpqIoXxJpzbf0NqQ==",
+      "dev": true,
+      "dependencies": {
+        "es5-ext": "~0.10.46",
+        "next-tick": "1"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/tsx": {
+      "version": "3.13.0",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-3.13.0.tgz",
+      "integrity": "sha512-rjmRpTu3as/5fjNq/kOkOtihgLxuIz6pbKdj9xwP4J5jOLkBxw/rjN5ANw+KyrrOXV5uB7HC8+SrrSJxT65y+A==",
+      "dev": true,
+      "dependencies": {
+        "esbuild": "~0.18.20",
+        "get-tsconfig": "^4.7.2",
+        "source-map-support": "^0.5.21"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/type": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/type/-/type-1.2.0.tgz",
+      "integrity": "sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==",
+      "dev": true
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
+      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/wordwrap": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
+      "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==",
+      "dev": true
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.22.2",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.22.2.tgz",
+      "integrity": "sha512-wvWkphh5WQsJbVk1tbx1l1Ly4yg+XecD+Mq280uBGt9wa5BKSWf4Mhp6GmrkPixhMxmabYY7RbzlwVP32pbGCg==",
+      "dev": true,
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}
diff --git a/examples/pg-proxy/package.json b/examples/pg-proxy/package.json
new file mode 100644
index 000000000..f947baf74
--- /dev/null
+++ b/examples/pg-proxy/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "pg-proxy",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test:types": "tsc --noEmit",
+    "start:script": "tsx src/index.ts",
+    "start:proxy-server": "tsx src/server.ts",
+    "generate": "drizzle-kit generate:pg --schema src/schema.ts"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.5.1",
+    "express": "^4.18.2",
+    "drizzle-orm": "workspace:../../drizzle-orm/dist",
+    "pg": "^8.11.3"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.18",
+    "@types/pg": "^8.10.3",
+    "drizzle-kit": "^0.19.13",
+    "tsx": "^3.13.0",
+    "typescript": "^5.2.2"
+  }
+}
diff --git a/examples/pg-proxy/src/index.ts b/examples/pg-proxy/src/index.ts
new file mode 100644
index 000000000..0cb2bfc9e
--- /dev/null
+++ b/examples/pg-proxy/src/index.ts
@@ -0,0 +1,38 @@
+import axios from 'axios';
+import { eq } from 'drizzle-orm/expressions';
+import { drizzle } from 'drizzle-orm/pg-proxy';
+import { migrate } from 'drizzle-orm/pg-proxy/migrator';
+import { cities, users } from './schema';
+
+async function main() {
+	const db = drizzle(async (sql, params, method) => {
+		try {
+			const rows = await axios.post('http://localhost:3000/query', { sql, params, method });
+
+			return { rows: rows.data };
+		} catch (e: any) {
+			console.error('Error from pg proxy server:', e.response.data);
+			return { rows: [] };
+		}
+	});
+
+	await migrate(db, async (queries) => {
+		try {
+			await axios.post('http://localhost:3000/migrate', { queries });
+		} catch (e) {
+			console.log(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: 'drizzle' });
+
+	const insertedCity = await db.insert(cities).values({ id: 1, name: 'name' }).returning();
+	console.log('insertedCity:', insertedCity);
+
+	const insertedUser = await db.insert(users).values({ id: 1, name: 'name', email: 'email', cityId: 1 });
+	console.log('insertedUser:', insertedUser);
+
+	const usersToCityResponse = await db.select().from(users).leftJoin(cities, eq(users.cityId, cities.id));
+	console.log('usersToCityResponse:', usersToCityResponse);
+}
+
+main();
diff --git a/examples/pg-proxy/src/schema.ts b/examples/pg-proxy/src/schema.ts
new file mode 100644
index 000000000..115af9da0
--- /dev/null
+++ b/examples/pg-proxy/src/schema.ts
@@ -0,0 +1,13 @@
+import { pgTable, serial, text } from "drizzle-orm/pg-core";
+
+export const users = pgTable('users', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+	cityId: serial('city_id').references(() => cities.id),
+});
+
+export const cities = pgTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
diff --git a/examples/pg-proxy/src/server.ts b/examples/pg-proxy/src/server.ts
new file mode 100644
index 000000000..7c75f68eb
--- /dev/null
+++ b/examples/pg-proxy/src/server.ts
@@ -0,0 +1,58 @@
+import { Client } from 'pg';
+import express from 'express';
+
+const app = express();
+app.use(express.json());
+const port = 3000;
+
+const client = new Client('postgres://postgres:postgres@localhost:5432/postgres');
+
+app.post('/query', async (req, res) => {
+	const { sql: sqlBody, params, method } = req.body;
+
+	if (method === 'all') {
+		try {
+            const result = await client.query({
+                text: sqlBody,
+                values: params,
+                rowMode: 'array',
+            });
+			res.send(result.rows);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else if (method === 'execute') {
+		try {
+            const result = await client.query({
+                text: sqlBody,
+                values: params,
+            });
+
+			res.send(result.rows);
+		} catch (e: any) {
+			res.status(500).json({ error: e });
+		}
+	} else {
+		res.status(500).json({ error: 'Unknown method value' });
+	}
+});
+
+app.post('/migrate', async (req, res) => {
+	const { queries } = req.body;
+
+    await client.query('BEGIN');
+    try {
+        for (const query of queries) {
+            await client.query(query);
+        }
+        await client.query('COMMIT');
+    } catch {
+        await client.query('ROLLBACK');
+    }
+
+	res.send({});
+});
+
+app.listen(port, () => {
+	console.log(`Example app listening on port ${port}`);
+});
diff --git a/examples/pg-proxy/tsconfig.json b/examples/pg-proxy/tsconfig.json
new file mode 100644
index 000000000..453f11f98
--- /dev/null
+++ b/examples/pg-proxy/tsconfig.json
@@ -0,0 +1,26 @@
+{
+	"compilerOptions": {
+		"target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+		"module": "commonjs" /* Specify what module code is generated. */,
+		"esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+		"forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+		"strict": true /* Enable all strict type-checking options. */,
+		"noImplicitAny": true /* Enable error reporting for expressions and declarations with an implied 'any' type. */,
+		"strictNullChecks": true /* When type checking, take into account 'null' and 'undefined'. */,
+		"strictFunctionTypes": true /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */,
+		"strictBindCallApply": true /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */,
+		"strictPropertyInitialization": true /* Check for class properties that are declared but not set in the constructor. */,
+		"noImplicitThis": true /* Enable error reporting when 'this' is given the type 'any'. */,
+		"useUnknownInCatchVariables": true /* Default catch clause variables as 'unknown' instead of 'any'. */,
+		"alwaysStrict": true /* Ensure 'use strict' is always emitted. */,
+		"noUnusedLocals": true /* Enable error reporting when local variables aren't read. */,
+		"noUnusedParameters": true /* Raise an error when a function parameter isn't read. */,
+		"exactOptionalPropertyTypes": true /* Interpret optional property types as written, rather than adding 'undefined'. */,
+		"noImplicitReturns": true /* Enable error reporting for codepaths that do not explicitly return in a function. */,
+		"noFallthroughCasesInSwitch": true /* Enable error reporting for fallthrough cases in switch statements. */,
+		"noUncheckedIndexedAccess": true /* Add 'undefined' to a type when accessed using an index. */,
+		"noImplicitOverride": true /* Ensure overriding members in derived classes are marked with an override modifier. */,
+		"noPropertyAccessFromIndexSignature": true /* Enforces using indexed accessors for keys declared using an indexed type. */,
+		"skipLibCheck": true /* Skip type checking all .d.ts files. */,
+	}
+}
diff --git a/integration-tests/test.ts b/integration-tests/test.ts
new file mode 100644
index 000000000..e6fced387
--- /dev/null
+++ b/integration-tests/test.ts
@@ -0,0 +1,204 @@
+import { sql } from 'drizzle-orm';
+// import { mysqlTable, serial, text } from 'drizzle-orm/mysql-core';
+import { drizzle } from 'drizzle-orm/mysql-proxy';
+// import postgres from "pg";
+import * as mysql from 'mysql2/promise';
+// import Docker from 'dockerode';
+// import getPort from 'get-port';
+// import { v4 as uuid } from 'uuid';
+
+
+// const pg = new postgres.Client("postgres://k6:k6@localhost:5432/northwind")
+
+async function createDockerDB(): Promise<string> {
+	// const docker = new Docker();
+	// const port = await getPort({ port: 3306 });
+	// const image = 'mysql:8';
+
+	// const pullStream = await docker.pull(image);
+	// await new Promise((resolve, reject) =>
+	// 	docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
+	// );
+
+	// const container = await docker.createContainer({
+	// 	Image: image,
+	// 	Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
+	// 	name: `drizzle-integration-tests-${uuid()}`,
+	// 	HostConfig: {
+	// 		AutoRemove: true,
+	// 		PortBindings: {
+	// 			'3306/tcp': [{ HostPort: `${port}` }],
+	// 		},
+	// 	},
+	// });
+
+	// await container.start();
+
+	return `mysql://root:mysql@127.0.0.1:3306/drizzle`;
+}
+
+const url = await createDockerDB();
+
+console.log(url)
+
+const client = await mysql.createConnection(url);
+
+// eslint-disable-next-line drizzle/require-entity-kind
+class ServerSimulator {
+	constructor(private db: mysql.Connection) {}
+
+	async query(sql: string, params: any[], method: 'all' | 'execute') {
+		if (method === 'all') {
+			try {
+				const result = await this.db.query({
+                    sql,
+                    values: params,
+					rowsAsArray: true,
+                    typeCast: function(field: any, next: any) {
+                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                            return field.string();
+                        }
+                        return next();
+                    },
+                });
+
+				return { data: result[0] as any };
+			} catch (e: any) {
+				return { error: e.message };
+			}
+		} else if (method === 'execute') {
+			try {
+				const result = await this.db.query({
+                    sql,
+                    values: params,
+                    typeCast: function(field: any, next: any) {
+                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                            return field.string();
+                        }
+                        return next();
+                    },
+				});
+
+				return { data: result[0] as any };
+			} catch (e: any) {
+				return { error: e.message };
+			}
+		} else {
+			return { error: 'Unknown method value' };
+		}
+	}
+
+	async migrations(queries: string[]) {
+		await this.db.query('BEGIN');
+		try {
+			for (const query of queries) {
+				await this.db.query(query);
+			}
+			await this.db.query('COMMIT');
+		} catch {
+			await this.db.query('ROLLBACK');
+		}
+
+		return {};
+	}
+}
+
+// const user = pgTable("customers", {
+//     id: text("customerid"),
+//     companyname: text("companyname")
+// })
+
+const serverSimulator = new ServerSimulator(client);
+
+const db = drizzle(async (sql, params, method) => {
+    try {
+        const response = await serverSimulator.query(sql, params, method);
+
+        if (response.error !== undefined) {
+            throw new Error(response.error);
+        }
+
+		console.log('response', response)
+
+        return { rows: response.data };
+    } catch (e: any) {
+        console.error('Error from pg proxy server:', e.message);
+        throw e;
+    }
+})
+
+// const usersMigratorTable = pgTable('users12', {
+// 	id: serial('id').primaryKey(),
+// 	name: text('name').notNull(),
+// 	email: text('email').notNull(),
+// });
+
+// const citiesTable = mysqlTable('cities', {
+// 	id: serial('id').primaryKey(),
+// 	name: text('name').notNull(),
+// });
+
+const main = async()=>{
+    // await db.execute(
+	// 	sql`insert into ${usersTable} (${name(usersTable.name.name)}) values (${'John'})`,
+	// );
+
+	// await db.execute(sql`
+	// 	create table if not exist \`cities\` (
+	// 		\`id\` serial primary key,
+	// 		\`name\` text not null
+	// 	)
+	// `,)
+
+	// await db.insert(citiesTable).values({
+	// 	name: 'New York',
+	// });
+
+	// const result = await db.execute<{ customerid: string }>(
+	// 	sql`select * from cities`,
+	// );
+
+    // console.log('result', result)
+
+	// const res = await db.select().from(citiesTable);
+
+	// console.log('res', res)
+
+	await db.execute(sql`drop table if exists \`userstest\``);
+	await db.execute(sql`drop table if exists \`users2\``);
+	await db.execute(sql`drop table if exists \`cities\``);
+
+	await db.execute(
+		sql`
+			create table \`userstest\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`verified\` boolean not null default false,
+				\`jsonb\` json,
+				\`created_at\` timestamp not null default now()
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`users2\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`city_id\` int references \`cities\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`cities\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+}
+
+main()
+
diff --git a/integration-tests/tests/imports.test.cjs b/integration-tests/tests/imports.test.cjs
index a4777f055..a7b11ff80 100644
--- a/integration-tests/tests/imports.test.cjs
+++ b/integration-tests/tests/imports.test.cjs
@@ -28,6 +28,10 @@ require('drizzle-orm/sql-js/migrator');
 require('drizzle-orm/sqlite-core');
 require('drizzle-orm/sqlite-proxy');
 require('drizzle-orm/sqlite-proxy/migrator');
+require('drizzle-orm/pg-proxy');
+require('drizzle-orm/pg-proxy/migrator');
+require('drizzle-orm/mysql-proxy');
+require('drizzle-orm/mysql-proxy/migrator');
 require('drizzle-orm/migrator');
 const { createInsertSchema: createZodInsertSchema } = require('drizzle-zod');
 const {
diff --git a/integration-tests/tests/imports.test.mjs b/integration-tests/tests/imports.test.mjs
index 50e94b4e7..d95566b41 100644
--- a/integration-tests/tests/imports.test.mjs
+++ b/integration-tests/tests/imports.test.mjs
@@ -28,6 +28,10 @@ import 'drizzle-orm/sql-js/migrator';
 import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm/sqlite-proxy';
 import 'drizzle-orm/sqlite-proxy/migrator';
+import 'drizzle-orm/pg-proxy';
+import 'drizzle-orm/pg-proxy/migrator';
+import 'drizzle-orm/mysql-proxy';
+import 'drizzle-orm/mysql-proxy/migrator';
 import 'drizzle-orm/migrator';
 import { createInsertSchema } from 'drizzle-zod';
 import { compatibilityVersion, npmVersion } from 'drizzle-orm/version';
diff --git a/integration-tests/tests/mysql-proxy.test.ts b/integration-tests/tests/mysql-proxy.test.ts
new file mode 100644
index 000000000..782039bf6
--- /dev/null
+++ b/integration-tests/tests/mysql-proxy.test.ts
@@ -0,0 +1,2111 @@
+import 'dotenv/config';
+
+import type { TestFn } from 'ava';
+import anyTest from 'ava';
+import Docker from 'dockerode';
+import {
+	asc,
+	eq,
+	gt,
+	inArray,
+	Name,
+	placeholder,
+	sql,
+} from 'drizzle-orm';
+import {
+	alias,
+	boolean,
+	date,
+	datetime,
+	getTableConfig,
+	getViewConfig,
+	int,
+	json,
+	mysqlEnum,
+	mysqlTable,
+	mysqlTableCreator,
+	mysqlView,
+	serial,
+	text,
+	time,
+	timestamp,
+	unique,
+	uniqueIndex,
+	uniqueKeyName,
+	year,
+} from 'drizzle-orm/mysql-core';
+import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
+import { drizzle as proxyDrizzle } from 'drizzle-orm/mysql-proxy';
+import type { MySqlRemoteDatabase } from 'drizzle-orm/mysql-proxy';
+import getPort from 'get-port';
+import * as mysql from 'mysql2/promise';
+import { v4 as uuid } from 'uuid';
+import { type Equal, Expect } from './utils.ts';
+
+const ENABLE_LOGGING = false;
+
+const usersTable = mysqlTable('userstest', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: json('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { fsp: 2 }).notNull().defaultNow(),
+});
+
+const users2Table = mysqlTable('users2', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: int('city_id').references(() => citiesTable.id),
+});
+
+const citiesTable = mysqlTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const datesTable = mysqlTable('datestable', {
+	date: date('date'),
+	dateAsString: date('date_as_string', { mode: 'string' }),
+	time: time('time', { fsp: 1 }),
+	datetime: datetime('datetime', { fsp: 2 }),
+	datetimeAsString: datetime('datetime_as_string', { fsp: 2, mode: 'string' }),
+	timestamp: timestamp('timestamp', { fsp: 3 }),
+	timestampAsString: timestamp('timestamp_as_string', { fsp: 3, mode: 'string' }),
+	year: year('year'),
+});
+
+const coursesTable = mysqlTable('courses', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	categoryId: int('category_id').references(() => courseCategoriesTable.id),
+});
+
+const courseCategoriesTable = mysqlTable('course_categories', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const orders = mysqlTable('orders', {
+	id: serial('id').primaryKey(),
+	region: text('region').notNull(),
+	product: text('product').notNull().$default(() => 'random_string'),
+	amount: int('amount').notNull(),
+	quantity: int('quantity').notNull(),
+});
+
+const usersMigratorTable = mysqlTable('users12', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+}, (table) => {
+	return {
+		name: uniqueIndex('').on(table.name).using('btree'),
+	};
+});
+
+// eslint-disable-next-line drizzle/require-entity-kind
+class ServerSimulator {
+	constructor(private db: mysql.Connection) {}
+
+	async query(sql: string, params: any[], method: 'all' | 'execute') {
+		if (method === 'all') {
+			try {
+				const result = await this.db.query({
+                    sql,
+                    values: params,
+					rowsAsArray: true,
+                    typeCast: function(field: any, next: any) {
+                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                            return field.string();
+                        }
+                        return next();
+                    },
+                });
+
+				return { data: result[0] as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else if (method === 'execute') {
+			try {
+				const result = await this.db.query({
+                    sql,
+                    values: params,
+                    typeCast: function(field: any, next: any) {
+                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+                            return field.string();
+                        }
+                        return next();
+                    },
+				});
+
+				return { data: result as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else {
+			return { error: 'Unknown method value' };
+		}
+	}
+
+	async migrations(queries: string[]) {
+		await this.db.query('BEGIN');
+		try {
+			for (const query of queries) {
+				await this.db.query(query);
+			}
+			await this.db.query('COMMIT');
+		} catch {
+			await this.db.query('ROLLBACK');
+		}
+
+		return {};
+	}
+}
+
+interface Context {
+	docker: Docker;
+	mysqlContainer: Docker.Container;
+	db: MySqlRemoteDatabase;
+	client: mysql.Connection;
+    serverSimulator: ServerSimulator;
+}
+
+const test = anyTest as TestFn<Context>;
+
+async function createDockerDB(ctx: Context): Promise<string> {
+	const docker = (ctx.docker = new Docker());
+	const port = await getPort({ port: 3306 });
+	const image = 'mysql:8';
+
+	const pullStream = await docker.pull(image);
+	await new Promise((resolve, reject) =>
+		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
+	);
+
+	ctx.mysqlContainer = await docker.createContainer({
+		Image: image,
+		Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
+		name: `drizzle-integration-tests-${uuid()}`,
+		HostConfig: {
+			AutoRemove: true,
+			PortBindings: {
+				'3306/tcp': [{ HostPort: `${port}` }],
+			},
+		},
+	});
+
+	await ctx.mysqlContainer.start();
+
+	return `mysql://root:mysql@127.0.0.1:${port}/drizzle`;
+}
+
+test.before(async (t) => {
+	const ctx = t.context;
+	const connectionString = process.env['MYSQL_CONNECTION_STRING'] ?? await createDockerDB(ctx);
+
+	const sleep = 1000;
+	let timeLeft = 20000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			ctx.client = await mysql.createConnection(connectionString);
+			await ctx.client.connect();
+			connected = true;
+			break;
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+	if (!connected) {
+		console.error('Cannot connect to MySQL');
+		await ctx.client?.end().catch(console.error);
+		await ctx.mysqlContainer?.stop().catch(console.error);
+		throw lastError;
+	}
+
+    ctx.serverSimulator = new ServerSimulator(ctx.client);
+
+	ctx.db = proxyDrizzle(async (sql, params, method) => {
+    try {
+        const response = await ctx.serverSimulator.query(sql, params, method);
+
+        if (response.error !== undefined) {
+            throw response.error;
+        }
+
+        return { rows: response.data };
+    } catch (e: any) {
+        console.error('Error from mysql proxy server:', e.message);
+        throw e;
+    }
+	}, { logger: ENABLE_LOGGING });
+});
+
+test.after.always(async (t) => {
+	const ctx = t.context;
+	await ctx.client?.end().catch(console.error);
+	await ctx.mysqlContainer?.stop().catch(console.error);
+});
+
+test.beforeEach(async (t) => {
+    try {
+        
+        const ctx = t.context;
+        await ctx.db.execute(sql`drop table if exists \`userstest\``);
+        await ctx.db.execute(sql`drop table if exists \`users2\``);
+        await ctx.db.execute(sql`drop table if exists \`cities\``);
+    
+        await ctx.db.execute(
+            sql`
+              create table \`userstest\` (
+                  \`id\` serial primary key,
+                  \`name\` text not null,
+                  \`verified\` boolean not null default false,
+                  \`jsonb\` json,
+                  \`created_at\` timestamp not null default now()
+              )
+            `,
+        );
+    
+        await ctx.db.execute(
+            sql`
+              create table \`users2\` (
+                  \`id\` serial primary key,
+                  \`name\` text not null,
+                  \`city_id\` int references \`cities\`(\`id\`)
+              )
+            `,
+        );
+    
+        await ctx.db.execute(
+            sql`
+              create table \`cities\` (
+                  \`id\` serial primary key,
+                  \`name\` text not null
+              )
+            `,
+        );
+    } catch (error) {
+        console.log('error', error)
+        throw error;
+    }
+});
+
+test.serial('table configs: unique third param', async (t) => {
+	const cities1Table = mysqlTable('cities1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: text('state'),
+	}, (t) => ({
+		f: unique('custom_name').on(t.name, t.state),
+		f1: unique('custom_name1').on(t.name, t.state),
+	}));
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	t.assert(tableConfig.uniqueConstraints.length === 2);
+
+	t.assert(tableConfig.uniqueConstraints[0]?.name === 'custom_name');
+	t.deepEqual(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name), ['name', 'state']);
+
+	t.assert(tableConfig.uniqueConstraints[1]?.name, 'custom_name1');
+	t.deepEqual(tableConfig.uniqueConstraints[1]?.columns.map((t) => t.name), ['name', 'state']);
+});
+
+test.serial('table configs: unique in column', async (t) => {
+	const cities1Table = mysqlTable('cities1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull().unique(),
+		state: text('state').unique('custom'),
+		field: text('field').unique('custom_field'),
+	});
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	const columnName = tableConfig.columns.find((it) => it.name === 'name');
+	t.assert(columnName?.uniqueName === uniqueKeyName(cities1Table, [columnName!.name]));
+	t.assert(columnName?.isUnique);
+
+	const columnState = tableConfig.columns.find((it) => it.name === 'state');
+	t.assert(columnState?.uniqueName === 'custom');
+	t.assert(columnState?.isUnique);
+
+	const columnField = tableConfig.columns.find((it) => it.name === 'field');
+	t.assert(columnField?.uniqueName === 'custom_field');
+	t.assert(columnField?.isUnique);
+});
+
+test.serial('select all fields', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+
+	t.assert(result[0]!.createdAt instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 2000);
+	t.deepEqual(result, [{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test.serial('select sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.serial('select typed sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.select({
+		name: sql<string>`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.serial('select distinct', async (t) => {
+	const { db } = t.context;
+
+	const usersDistinctTable = mysqlTable('users_distinct', {
+		id: int('id').notNull(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+	await db.execute(sql`create table ${usersDistinctTable} (id int, name text)`);
+
+	await db.insert(usersDistinctTable).values([
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+		{ id: 1, name: 'Jane' },
+	]);
+	const users = await db.selectDistinct().from(usersDistinctTable).orderBy(
+		usersDistinctTable.id,
+		usersDistinctTable.name,
+	);
+
+	await db.execute(sql`drop table ${usersDistinctTable}`);
+
+	t.deepEqual(users, [{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+});
+
+test.serial('insert returning sql', async (t) => {
+	const { db } = t.context;
+
+	const [result, _] = await db.insert(usersTable).values({ name: 'John' });
+
+	t.deepEqual(result.insertId, 1);
+});
+
+test.serial('delete returning sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	t.is(users[0].affectedRows, 1);
+});
+
+test.serial('update returning sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	t.is(users[0].changedRows, 1);
+});
+
+test.serial('update with returning all fields', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	const users = await db.select().from(usersTable).where(eq(usersTable.id, 1));
+
+	t.is(updatedUsers[0].changedRows, 1);
+
+	t.assert(users[0]!.createdAt instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	// not timezone based timestamp, thats why it should not work here
+	// t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 2000);
+	t.deepEqual(users, [{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt }]);
+});
+
+test.serial('update with returning partial', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const updatedUsers = await db.update(usersTable).set({ name: 'Jane' }).where(eq(usersTable.name, 'John'));
+
+	const users = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	t.deepEqual(updatedUsers[0].changedRows, 1);
+
+	t.deepEqual(users, [{ id: 1, name: 'Jane' }]);
+});
+
+test.serial('delete with returning all fields', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	t.is(deletedUser[0].affectedRows, 1);
+});
+
+test.serial('delete with returning partial', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const deletedUser = await db.delete(usersTable).where(eq(usersTable.name, 'John'));
+
+	t.is(deletedUser[0].affectedRows, 1);
+});
+
+test.serial('insert + select', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+	t.deepEqual(result, [{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt }]);
+
+	await db.insert(usersTable).values({ name: 'Jane' });
+	const result2 = await db.select().from(usersTable);
+	t.deepEqual(result2, [
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+		{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+	]);
+});
+
+test.serial('json insert', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+	}).from(usersTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test.serial('insert with overridden default values', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John', verified: true });
+	const result = await db.select().from(usersTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt }]);
+});
+
+test.serial('insert many', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		jsonb: usersTable.jsonb,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test.serial('insert many with returning', async (t) => {
+	const { db } = t.context;
+
+	const result = await db.insert(usersTable).values([
+		{ name: 'John' },
+		{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+		{ name: 'Jane' },
+		{ name: 'Austin', verified: true },
+	]);
+
+	t.is(result[0].affectedRows, 4);
+});
+
+test.serial('select with group by as field', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.name);
+
+	t.deepEqual(result, [{ name: 'John' }, { name: 'Jane' }]);
+});
+
+test.serial('select with group by as sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`);
+
+	t.deepEqual(result, [{ name: 'John' }, { name: 'Jane' }]);
+});
+
+test.serial('$default function', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`orders\``);
+	await db.execute(
+		sql`
+			create table \`orders\` (
+				\`id\` serial primary key,
+				\`region\` text not null,
+				\`product\` text not null,
+				\`amount\` int not null,
+				\`quantity\` int not null
+			)
+		`,
+	);
+
+	await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 });
+	const selectedOrder = await db.select().from(orders);
+
+	t.deepEqual(selectedOrder, [{
+		id: 1,
+		amount: 1,
+		quantity: 1,
+		region: 'Ukraine',
+		product: 'random_string',
+	}]);
+});
+
+test.serial('$default with empty array', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`s_orders\``);
+	await db.execute(
+		sql`
+			create table \`s_orders\` (
+				\`id\` serial primary key,
+				\`region\` text default ('Ukraine'),
+				\`product\` text not null
+			)
+		`,
+	);
+
+	const users = mysqlTable('s_orders', {
+		id: serial('id').primaryKey(),
+		region: text('region').default('Ukraine'),
+		product: text('product').$defaultFn(() => 'random_string'),
+	});
+
+	await db.insert(users).values({});
+	const selectedOrder = await db.select().from(users);
+
+	t.deepEqual(selectedOrder, [{
+		id: 1,
+		region: 'Ukraine',
+		product: 'random_string',
+	}]);
+});
+
+test.serial('select with group by as sql + column', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+	t.deepEqual(result, [{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test.serial('select with group by as column + sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+	t.deepEqual(result, [{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+});
+
+test.serial('select with group by complex query', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db.select({ name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`)
+		.orderBy(asc(usersTable.name))
+		.limit(1);
+
+	t.deepEqual(result, [{ name: 'Jane' }]);
+});
+
+test.serial('build query', async (t) => {
+	const { db } = t.context;
+
+	const query = db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable)
+		.groupBy(usersTable.id, usersTable.name)
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql: `select \`id\`, \`name\` from \`userstest\` group by \`userstest\`.\`id\`, \`userstest\`.\`name\``,
+		params: [],
+	});
+});
+
+test.serial('Query check: Insert all defaults in 1 row', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	const query = db
+		.insert(users)
+		.values({})
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql: 'insert into `users` (`id`, `name`, `state`) values (default, default, default)',
+		params: [],
+	});
+});
+
+test.serial('Query check: Insert all defaults in multiple rows', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state').default('UA'),
+	});
+
+	const query = db
+		.insert(users)
+		.values([{}, {}])
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql: 'insert into `users` (`id`, `name`, `state`) values (default, default, default), (default, default, default)',
+		params: [],
+	});
+});
+
+test.serial('Insert all defaults in 1 row', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('empty_insert_single', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial primary key, name text default ('Dan'), state text)`,
+	);
+
+	await db.insert(users).values({});
+
+	const res = await db.select().from(users);
+
+	t.deepEqual(res, [{ id: 1, name: 'Dan', state: null }]);
+});
+
+test.serial('Insert all defaults in multiple rows', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('empty_insert_multiple', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial primary key, name text default ('Dan'), state text)`,
+	);
+
+	await db.insert(users).values([{}, {}]);
+
+	const res = await db.select().from(users);
+
+	t.deepEqual(res, [{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
+});
+
+test.serial('build query insert with onDuplicate', async (t) => {
+	const { db } = t.context;
+
+	const query = db.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onDuplicateKeyUpdate({ set: { name: 'John1' } })
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql:
+			'insert into `userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (default, ?, default, ?, default) on duplicate key update `name` = ?',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test.serial('insert with onDuplicate', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable)
+		.values({ name: 'John' });
+
+	await db.insert(usersTable)
+		.values({ id: 1, name: 'John' })
+		.onDuplicateKeyUpdate({ set: { name: 'John1' } });
+
+	const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	t.deepEqual(res, [{ id: 1, name: 'John1' }]);
+});
+
+test.serial('insert conflict', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable)
+		.values({ name: 'John' });
+
+	await t.throwsAsync(
+		() => db.insert(usersTable).values({ id: 1, name: 'John1' }),
+		{
+			code: 'ER_DUP_ENTRY',
+			message: "Duplicate entry '1' for key 'userstest.PRIMARY'",
+		},
+	);
+});
+
+test.serial('insert conflict with ignore', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable)
+		.values({ name: 'John' });
+
+	await db.insert(usersTable)
+		.ignore()
+		.values({ id: 1, name: 'John1' });
+
+	const res = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable).where(
+		eq(usersTable.id, 1),
+	);
+
+	t.deepEqual(res, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('insert sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: sql`${'John'}` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('partial join with alias', async (t) => {
+	const { db } = t.context;
+	const customerAlias = alias(usersTable, 'customer');
+
+	await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select({
+			user: {
+				id: usersTable.id,
+				name: usersTable.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		}).from(usersTable)
+		.leftJoin(customerAlias, eq(customerAlias.id, 11))
+		.where(eq(usersTable.id, 10));
+
+	t.deepEqual(result, [{
+		user: { id: 10, name: 'Ivan' },
+		customer: { id: 11, name: 'Hans' },
+	}]);
+});
+
+test.serial('full join with alias', async (t) => {
+	const { db } = t.context;
+
+	const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select().from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	t.deepEqual(result, [{
+		users: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('select from alias', async (t) => {
+	const { db } = t.context;
+
+	const mysqlTable = mysqlTableCreator((name) => `prefixed_${name}`);
+
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+	const user = alias(users, 'user');
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select()
+		.from(user)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(user.id, 10));
+
+	t.deepEqual(result, [{
+		user: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('insert with spaces', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test.serial('prepared statement', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const statement = db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+	}).from(usersTable)
+		.prepare();
+	const result = await statement.execute();
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('prepared statement reuse', async (t) => {
+	const { db } = t.context;
+
+	const stmt = db.insert(usersTable).values({
+		verified: true,
+		name: placeholder('name'),
+	}).prepare();
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+		verified: usersTable.verified,
+	}).from(usersTable);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John 0', verified: true },
+		{ id: 2, name: 'John 1', verified: true },
+		{ id: 3, name: 'John 2', verified: true },
+		{ id: 4, name: 'John 3', verified: true },
+		{ id: 5, name: 'John 4', verified: true },
+		{ id: 6, name: 'John 5', verified: true },
+		{ id: 7, name: 'John 6', verified: true },
+		{ id: 8, name: 'John 7', verified: true },
+		{ id: 9, name: 'John 8', verified: true },
+		{ id: 10, name: 'John 9', verified: true },
+	]);
+});
+
+test.serial('prepared statement with placeholder in .where', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const stmt = db.select({
+		id: usersTable.id,
+		name: usersTable.name,
+	}).from(usersTable)
+		.where(eq(usersTable.id, placeholder('id')))
+		.prepare();
+	const result = await stmt.execute({ id: 1 });
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('migrator', async (t) => {
+	const { db, serverSimulator } = t.context;
+
+	await db.execute(sql`drop table if exists cities_migration`);
+	await db.execute(sql`drop table if exists users_migration`);
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists __drizzle_migrations`);
+
+	await migrate(db, async (queries) => {
+		try {
+			await serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: './drizzle2/mysql' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table cities_migration`);
+	await db.execute(sql`drop table users_migration`);
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table __drizzle_migrations`);
+});
+
+test.serial('insert via db.execute + select via db.execute', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`insert into ${usersTable} (${new Name(usersTable.name.name)}) values (${'John'})`);
+
+	const result = await db.execute<{ id: number; name: string }>(sql`select id, name from ${usersTable}`);
+	t.deepEqual(result[0], [{ id: 1, name: 'John' }]);
+});
+
+test.serial('insert via db.execute w/ query builder', async (t) => {
+	const { db } = t.context;
+
+	const inserted = await db.execute(
+		db.insert(usersTable).values({ name: 'John' }),
+	);
+	t.is(inserted[0].affectedRows, 1);
+});
+
+test.serial('insert + select all possible dates', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`datestable\``);
+	await db.execute(
+		sql`
+			create table \`datestable\` (
+				\`date\` date,
+				\`date_as_string\` date,
+				\`time\` time,
+				\`datetime\` datetime,
+				\`datetime_as_string\` datetime,
+				\`timestamp\` timestamp(3),
+				\`timestamp_as_string\` timestamp(3),
+				\`year\` year
+			)
+		`,
+	);
+
+	const date = new Date('2022-11-11');
+	const dateWithMilliseconds = new Date('2022-11-11 12:12:12.123');
+
+	await db.insert(datesTable).values({
+		date: date,
+		dateAsString: '2022-11-11',
+		time: '12:12:12',
+		datetime: date,
+		year: 22,
+		datetimeAsString: '2022-11-11 12:12:12',
+		timestamp: dateWithMilliseconds,
+		timestampAsString: '2022-11-11 12:12:12.123',
+	});
+
+	const res = await db.select().from(datesTable);
+
+	t.assert(res[0]?.date instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	t.assert(res[0]?.datetime instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	t.assert(typeof res[0]?.dateAsString === 'string');
+	t.assert(typeof res[0]?.datetimeAsString === 'string');
+
+	t.deepEqual(res, [{
+		date: new Date('2022-11-11'),
+		dateAsString: '2022-11-11',
+		time: '12:12:12',
+		datetime: new Date('2022-11-11'),
+		year: 2022,
+		datetimeAsString: '2022-11-11 12:12:12',
+		timestamp: new Date('2022-11-11 12:12:12.123'),
+		timestampAsString: '2022-11-11 12:12:12.123',
+	}]);
+
+	await db.execute(sql`drop table if exists \`datestable\``);
+});
+
+const tableWithEnums = mysqlTable('enums_test_case', {
+	id: serial('id').primaryKey(),
+	enum1: mysqlEnum('enum1', ['a', 'b', 'c']).notNull(),
+	enum2: mysqlEnum('enum2', ['a', 'b', 'c']).default('a'),
+	enum3: mysqlEnum('enum3', ['a', 'b', 'c']).notNull().default('b'),
+});
+
+test.serial('Mysql enum test case #1', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`enums_test_case\``);
+
+	await db.execute(sql`
+		create table \`enums_test_case\` (
+			\`id\` serial primary key,
+			\`enum1\` ENUM('a', 'b', 'c') not null,
+			\`enum2\` ENUM('a', 'b', 'c') default 'a',
+			\`enum3\` ENUM('a', 'b', 'c') not null default 'b'
+		)
+	`);
+
+	await db.insert(tableWithEnums).values([
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a' },
+	]);
+
+	const res = await db.select().from(tableWithEnums);
+
+	await db.execute(sql`drop table \`enums_test_case\``);
+
+	t.deepEqual(res, [
+		{ id: 1, enum1: 'a', enum2: 'b', enum3: 'c' },
+		{ id: 2, enum1: 'a', enum2: 'a', enum3: 'c' },
+		{ id: 3, enum1: 'a', enum2: 'a', enum3: 'b' },
+	]);
+});
+
+test.serial('left join (flat object fields)', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable)
+		.values([{ name: 'Paris' }, { name: 'London' }]);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+	const res = await db.select({
+		userId: users2Table.id,
+		userName: users2Table.name,
+		cityId: citiesTable.id,
+		cityName: citiesTable.name,
+	}).from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	t.deepEqual(res, [
+		{ userId: 1, userName: 'John', cityId: 1, cityName: 'Paris' },
+		{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+	]);
+});
+
+test.serial('left join (grouped fields)', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable)
+		.values([{ name: 'Paris' }, { name: 'London' }]);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+	const res = await db.select({
+		id: users2Table.id,
+		user: {
+			name: users2Table.name,
+			nameUpper: sql<string>`upper(${users2Table.name})`,
+		},
+		city: {
+			id: citiesTable.id,
+			name: citiesTable.name,
+			nameUpper: sql<string>`upper(${citiesTable.name})`,
+		},
+	}).from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	t.deepEqual(res, [
+		{
+			id: 1,
+			user: { name: 'John', nameUpper: 'JOHN' },
+			city: { id: 1, name: 'Paris', nameUpper: 'PARIS' },
+		},
+		{
+			id: 2,
+			user: { name: 'Jane', nameUpper: 'JANE' },
+			city: null,
+		},
+	]);
+});
+
+test.serial('left join (all fields)', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable)
+		.values([{ name: 'Paris' }, { name: 'London' }]);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane' }]);
+
+	const res = await db.select().from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	t.deepEqual(res, [
+		{
+			users2: {
+				id: 1,
+				name: 'John',
+				cityId: 1,
+			},
+			cities: {
+				id: 1,
+				name: 'Paris',
+			},
+		},
+		{
+			users2: {
+				id: 2,
+				name: 'Jane',
+				cityId: null,
+			},
+			cities: null,
+		},
+	]);
+});
+
+test.serial('join subquery', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`courses\``);
+	await db.execute(sql`drop table if exists \`course_categories\``);
+
+	await db.execute(
+		sql`
+			create table \`course_categories\` (
+				\`id\` serial primary key,
+				\`name\` text not null
+			)
+		`,
+	);
+
+	await db.execute(
+		sql`
+			create table \`courses\` (
+				\`id\` serial primary key,
+				\`name\` text not null,
+				\`category_id\` int references \`course_categories\`(\`id\`)
+			)
+		`,
+	);
+
+	await db.insert(courseCategoriesTable).values([
+		{ name: 'Category 1' },
+		{ name: 'Category 2' },
+		{ name: 'Category 3' },
+		{ name: 'Category 4' },
+	]);
+
+	await db.insert(coursesTable).values([
+		{ name: 'Development', categoryId: 2 },
+		{ name: 'IT & Software', categoryId: 3 },
+		{ name: 'Marketing', categoryId: 4 },
+		{ name: 'Design', categoryId: 1 },
+	]);
+
+	const sq2 = db
+		.select({
+			categoryId: courseCategoriesTable.id,
+			category: courseCategoriesTable.name,
+			total: sql<number>`count(${courseCategoriesTable.id})`,
+		})
+		.from(courseCategoriesTable)
+		.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+		.as('sq2');
+
+	const res = await db
+		.select({
+			courseName: coursesTable.name,
+			categoryId: sq2.categoryId,
+		})
+		.from(coursesTable)
+		.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+		.orderBy(coursesTable.name);
+
+	t.deepEqual(res, [
+		{ courseName: 'Design', categoryId: 1 },
+		{ courseName: 'Development', categoryId: 2 },
+		{ courseName: 'IT & Software', categoryId: 3 },
+		{ courseName: 'Marketing', categoryId: 4 },
+	]);
+
+	await db.execute(sql`drop table if exists \`courses\``);
+	await db.execute(sql`drop table if exists \`course_categories\``);
+});
+
+test.serial('with ... select', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`orders\``);
+	await db.execute(
+		sql`
+			create table \`orders\` (
+				\`id\` serial primary key,
+				\`region\` text not null,
+				\`product\` text not null,
+				\`amount\` int not null,
+				\`quantity\` int not null
+			)
+		`,
+	);
+
+	await db.insert(orders).values([
+		{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+		{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+	]);
+
+	const regionalSales = db
+		.$with('regional_sales')
+		.as(
+			db
+				.select({
+					region: orders.region,
+					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+				})
+				.from(orders)
+				.groupBy(orders.region),
+		);
+
+	const topRegions = db
+		.$with('top_regions')
+		.as(
+			db
+				.select({
+					region: regionalSales.region,
+				})
+				.from(regionalSales)
+				.where(
+					gt(
+						regionalSales.totalSales,
+						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+					),
+				),
+		);
+
+	const result = await db
+		.with(regionalSales, topRegions)
+		.select({
+			region: orders.region,
+			product: orders.product,
+			productUnits: sql<number>`cast(sum(${orders.quantity}) as unsigned)`,
+			productSales: sql<number>`cast(sum(${orders.amount}) as unsigned)`,
+		})
+		.from(orders)
+		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+		.groupBy(orders.region, orders.product)
+		.orderBy(orders.region, orders.product);
+
+	t.deepEqual(result, [
+		{
+			region: 'Europe',
+			product: 'A',
+			productUnits: 3,
+			productSales: 30,
+		},
+		{
+			region: 'Europe',
+			product: 'B',
+			productUnits: 5,
+			productSales: 50,
+		},
+		{
+			region: 'US',
+			product: 'A',
+			productUnits: 7,
+			productSales: 70,
+		},
+		{
+			region: 'US',
+			product: 'B',
+			productUnits: 9,
+			productSales: 90,
+		},
+	]);
+});
+
+test.serial('select from subquery sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const sq = db
+		.select({ name: sql<string>`concat(${users2Table.name}, " modified")`.as('name') })
+		.from(users2Table)
+		.as('sq');
+
+	const res = await db.select({ name: sq.name }).from(sq);
+
+	t.deepEqual(res, [{ name: 'John modified' }, { name: 'Jane modified' }]);
+});
+
+test.serial('select a field without joining its table', (t) => {
+	const { db } = t.context;
+
+	t.throws(() => db.select({ name: users2Table.name }).from(usersTable).prepare());
+});
+
+test.serial('select all fields from subquery without alias', (t) => {
+	const { db } = t.context;
+
+	const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+
+	t.throws(() => db.select().from(sq).prepare());
+});
+
+test.serial('select count()', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+	t.deepEqual(res, [{ count: 2 }]);
+});
+
+test.serial('select for ...', (t) => {
+	const { db } = t.context;
+
+	{
+		const query = db.select().from(users2Table).for('update').toSQL();
+		t.regex(query.sql, / for update$/);
+	}
+	{
+		const query = db.select().from(users2Table).for('share', { skipLocked: true }).toSQL();
+		t.regex(query.sql, / for share skip locked$/);
+	}
+	{
+		const query = db.select().from(users2Table).for('update', { noWait: true }).toSQL();
+		t.regex(query.sql, / for update no wait$/);
+	}
+});
+
+test.serial('having', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
+		name: 'Jack',
+		cityId: 2,
+	}]);
+
+	const result = await db
+		.select({
+			id: citiesTable.id,
+			name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+			usersCount: sql<number>`count(${users2Table.id})`.as('users_count'),
+		})
+		.from(citiesTable)
+		.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+		.where(({ name }) => sql`length(${name}) >= 3`)
+		.groupBy(citiesTable.id)
+		.having(({ usersCount }) => sql`${usersCount} > 0`)
+		.orderBy(({ name }) => name);
+
+	t.deepEqual(result, [
+		{
+			id: 1,
+			name: 'LONDON',
+			usersCount: 2,
+		},
+		{
+			id: 2,
+			name: 'PARIS',
+			usersCount: 1,
+		},
+	]);
+});
+
+test.serial('view', async (t) => {
+	const { db } = t.context;
+
+	const newYorkers1 = mysqlView('new_yorkers')
+		.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+	const newYorkers2 = mysqlView('new_yorkers', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+	const newYorkers3 = mysqlView('new_yorkers', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	}).existing();
+
+	await db.execute(sql`create view new_yorkers as ${getViewConfig(newYorkers1).query}`);
+
+	await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+	await db.insert(users2Table).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 1 },
+		{ name: 'Jack', cityId: 2 },
+	]);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers2);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers3);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+		t.deepEqual(result, [
+			{ name: 'John' },
+			{ name: 'Jane' },
+		]);
+	}
+
+	await db.execute(sql`drop view ${newYorkers1}`);
+});
+
+test.serial('select from raw sql', async (t) => {
+	const { db } = t.context;
+
+	const result = await db.select({
+		id: sql<number>`id`,
+		name: sql<string>`name`,
+	}).from(sql`(select 1 as id, 'John' as name) as users`);
+
+	Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('select from raw sql with joins', async (t) => {
+	const { db } = t.context;
+
+	const result = await db
+		.select({
+			id: sql<number>`users.id`,
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
+
+	Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+	]);
+});
+
+test.serial('join on aliased sql from select', async (t) => {
+	const { db } = t.context;
+
+	const result = await db
+		.select({
+			userId: sql<number>`users.id`.as('userId'),
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityId: sql<number>`cities.id`.as('cityId'),
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test.serial('join on aliased sql from with clause', async (t) => {
+	const { db } = t.context;
+
+	const users = db.$with('users').as(
+		db.select({
+			id: sql<number>`id`.as('userId'),
+			name: sql<string>`name`.as('userName'),
+			city: sql<string>`city`.as('city'),
+		}).from(
+			sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+		),
+	);
+
+	const cities = db.$with('cities').as(
+		db.select({
+			id: sql<number>`id`.as('cityId'),
+			name: sql<string>`name`.as('cityName'),
+		}).from(
+			sql`(select 1 as id, 'Paris' as name) as cities`,
+		),
+	);
+
+	const result = await db
+		.with(users, cities)
+		.select({
+			userId: users.id,
+			name: users.name,
+			userCity: users.city,
+			cityId: cities.id,
+			cityName: cities.name,
+		})
+		.from(users)
+		.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test.serial('prefixed table', async (t) => {
+	const { db } = t.context;
+
+	const mysqlTable = mysqlTableCreator((name) => `myprefix_${name}`);
+
+	const users = mysqlTable('test_prefixed_table_with_unique_name', {
+		id: int('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table myprefix_test_prefixed_table_with_unique_name (id int not null primary key, name text not null)`,
+	);
+
+	await db.insert(users).values({ id: 1, name: 'John' });
+
+	const result = await db.select().from(users);
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('orderBy with aliased column', (t) => {
+	const { db } = t.context;
+
+	const query = db.select({
+		test: sql`something`.as('test'),
+	}).from(users2Table).orderBy((fields) => fields.test).toSQL();
+
+	t.deepEqual(query.sql, 'select something as `test` from `users2` order by `test`');
+});
+
+test.serial('timestamp timezone', async (t) => {
+	const { db } = t.context;
+
+	const date = new Date(Date.parse('2020-01-01T12:34:56+07:00'));
+
+	await db.insert(usersTable).values({ name: 'With default times' });
+	await db.insert(usersTable).values({
+		name: 'Without default times',
+		createdAt: date,
+	});
+	const users = await db.select().from(usersTable);
+
+	// check that the timestamps are set correctly for default times
+	t.assert(Math.abs(users[0]!.createdAt.getTime() - Date.now()) < 2000);
+
+	// check that the timestamps are set correctly for non default times
+	t.assert(Math.abs(users[1]!.createdAt.getTime() - date.getTime()) < 2000);
+});
+
+// TODO: implement transactions
+// test.serial('transaction', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = mysqlTable('users_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		balance: int('balance').notNull(),
+// 	});
+// 	const products = mysqlTable('products_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		price: int('price').notNull(),
+// 		stock: int('stock').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+// 	await db.execute(sql`drop table if exists ${products}`);
+
+// 	await db.execute(sql`create table users_transactions (id serial not null primary key, balance int not null)`);
+// 	await db.execute(
+// 		sql`create table products_transactions (id serial not null primary key, price int not null, stock int not null)`,
+// 	);
+
+// 	const [{ insertId: userId }] = await db.insert(users).values({ balance: 100 });
+// 	const user = await db.select().from(users).where(eq(users.id, userId)).then((rows) => rows[0]!);
+// 	const [{ insertId: productId }] = await db.insert(products).values({ price: 10, stock: 10 });
+// 	const product = await db.select().from(products).where(eq(products.id, productId)).then((rows) => rows[0]!);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+// 		await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, [{ id: 1, balance: 90 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// 	await db.execute(sql`drop table ${products}`);
+// });
+
+// TODO: implement transactions
+// test.serial('transaction rollback', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = mysqlTable('users_transactions_rollback', {
+// 		id: serial('id').primaryKey(),
+// 		balance: int('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_transactions_rollback (id serial not null primary key, balance int not null)`,
+// 	);
+
+// 	await t.throwsAsync(async () =>
+// 		await db.transaction(async (tx) => {
+// 			await tx.insert(users).values({ balance: 100 });
+// 			tx.rollback();
+// 		}), new TransactionRollbackError());
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, []);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// TODO: implement transactions
+// test.serial('nested transaction', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = mysqlTable('users_nested_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		balance: int('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_nested_transactions (id serial not null primary key, balance int not null)`,
+// 	);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.insert(users).values({ balance: 100 });
+
+// 		await tx.transaction(async (tx) => {
+// 			await tx.update(users).set({ balance: 200 });
+// 		});
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, [{ id: 1, balance: 200 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// TODO: implement transactions
+// test.serial('nested transaction rollback', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = mysqlTable('users_nested_transactions_rollback', {
+// 		id: serial('id').primaryKey(),
+// 		balance: int('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_nested_transactions_rollback (id serial not null primary key, balance int not null)`,
+// 	);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.insert(users).values({ balance: 100 });
+
+// 		await t.throwsAsync(async () =>
+// 			await tx.transaction(async (tx) => {
+// 				await tx.update(users).set({ balance: 200 });
+// 				tx.rollback();
+// 			}), new TransactionRollbackError());
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, [{ id: 1, balance: 100 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+test.serial('join subquery with join', async (t) => {
+	const { db } = t.context;
+
+	const internalStaff = mysqlTable('internal_staff', {
+		userId: int('user_id').notNull(),
+	});
+
+	const customUser = mysqlTable('custom_user', {
+		id: int('id').notNull(),
+	});
+
+	const ticket = mysqlTable('ticket', {
+		staffId: int('staff_id').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${internalStaff}`);
+	await db.execute(sql`drop table if exists ${customUser}`);
+	await db.execute(sql`drop table if exists ${ticket}`);
+
+	await db.execute(sql`create table internal_staff (user_id integer not null)`);
+	await db.execute(sql`create table custom_user (id integer not null)`);
+	await db.execute(sql`create table ticket (staff_id integer not null)`);
+
+	await db.insert(internalStaff).values({ userId: 1 });
+	await db.insert(customUser).values({ id: 1 });
+	await db.insert(ticket).values({ staffId: 1 });
+
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+		.as('internal_staff');
+
+	const mainQuery = await db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+	t.deepEqual(mainQuery, [{
+		ticket: { staffId: 1 },
+		internal_staff: {
+			internal_staff: { userId: 1 },
+			custom_user: { id: 1 },
+		},
+	}]);
+
+	await db.execute(sql`drop table ${internalStaff}`);
+	await db.execute(sql`drop table ${customUser}`);
+	await db.execute(sql`drop table ${ticket}`);
+});
+
+test.serial('subquery with view', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('users_subquery_view', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.$with('sq').as(db.select().from(newYorkers));
+	const result = await db.with(sq).select().from(sq);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 1 },
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('join view as subquery', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('users_join_view', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: int('city_id').notNull(),
+	});
+
+	const newYorkers = mysqlView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+	const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
+
+	t.deepEqual(result, [
+		{
+			users_join_view: { id: 1, name: 'John', cityId: 1 },
+			new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+		{
+			users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+			new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+});
+
+// TODO: implement iterator
+// test.serial('select iterator', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = mysqlTable('users_iterator', {
+// 		id: serial('id').primaryKey(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+// 	await db.execute(sql`create table ${users} (id serial not null primary key)`);
+
+// 	await db.insert(users).values([{}, {}, {}]);
+
+// 	const iter = db.select().from(users).iterator();
+// 	const result: InferModel<typeof users>[] = [];
+
+// 	for await (const row of iter) {
+// 		result.push(row);
+// 	}
+
+// 	t.deepEqual(result, [{ id: 1 }, { id: 2 }, { id: 3 }]);
+// });
+
+// TODO: implement iterator
+// test.serial('select iterator w/ prepared statement', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = mysqlTable('users_iterator', {
+// 		id: serial('id').primaryKey(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+// 	await db.execute(sql`create table ${users} (id serial not null primary key)`);
+
+// 	await db.insert(users).values([{}, {}, {}]);
+
+// 	const prepared = db.select().from(users).prepare();
+// 	const iter = prepared.iterator();
+// 	const result: InferModel<typeof users>[] = [];
+
+// 	for await (const row of iter) {
+// 		result.push(row);
+// 	}
+
+// 	t.deepEqual(result, [{ id: 1 }, { id: 2 }, { id: 3 }]);
+// });
+
+test.serial('insert undefined', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text)`,
+	);
+
+	await t.notThrowsAsync(async () => await db.insert(users).values({ name: undefined }));
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('update undefined', async (t) => {
+	const { db } = t.context;
+
+	const users = mysqlTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text)`,
+	);
+
+	await t.throwsAsync(async () => await db.update(users).set({ name: undefined }));
+	await t.notThrowsAsync(async () => await db.update(users).set({ id: 1, name: undefined }));
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('utc config for datetime', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(sql`drop table if exists \`datestable\``);
+	await db.execute(
+		sql`
+			create table \`datestable\` (
+				\`datetime_utc\` datetime(3),
+				\`datetime\` datetime(3),
+				\`datetime_as_string\` datetime
+			)
+		`,
+	);
+	const datesTable = mysqlTable('datestable', {
+		datetimeUTC: datetime('datetime_utc', { fsp: 3, mode: 'date' }),
+		datetime: datetime('datetime', { fsp: 3 }),
+		datetimeAsString: datetime('datetime_as_string', { mode: 'string' }),
+	});
+
+	const dateObj = new Date('2022-11-11');
+	const dateUtc = new Date('2022-11-11T12:12:12.122Z');
+
+	await db.insert(datesTable).values({
+		datetimeUTC: dateUtc,
+		datetime: dateObj,
+		datetimeAsString: '2022-11-11 12:12:12',
+	});
+
+	const res = await db.select().from(datesTable);
+
+	const [rawSelect] = await db.execute(sql`select \`datetime_utc\` from \`datestable\``);
+	const selectedRow = (rawSelect as unknown as [{ datetime_utc: string }])[0];
+
+	t.is(selectedRow.datetime_utc, '2022-11-11 12:12:12.122');
+	t.deepEqual(new Date(selectedRow.datetime_utc.replace(' ', 'T') + 'Z'), dateUtc);
+
+	t.assert(res[0]?.datetime instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	t.assert(res[0]?.datetimeUTC instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	t.assert(typeof res[0]?.datetimeAsString === 'string');
+
+	t.deepEqual(res, [{
+		datetimeUTC: dateUtc,
+		datetime: new Date('2022-11-11'),
+		datetimeAsString: '2022-11-11 12:12:12',
+	}]);
+
+	await db.execute(sql`drop table if exists \`datestable\``);
+});
diff --git a/integration-tests/tests/pg-proxy.test.ts b/integration-tests/tests/pg-proxy.test.ts
new file mode 100644
index 000000000..93c7e5932
--- /dev/null
+++ b/integration-tests/tests/pg-proxy.test.ts
@@ -0,0 +1,2584 @@
+import 'dotenv/config';
+
+import type { TestFn } from 'ava';
+import anyTest from 'ava';
+import Docker from 'dockerode';
+import {
+	and,
+	asc,
+	eq,
+	gt,
+	gte,
+	inArray,
+	lt,
+	name,
+	placeholder,
+	type SQL,
+	sql,
+	type SQLWrapper,
+	arrayContains,
+	arrayContained,
+	arrayOverlaps
+} from 'drizzle-orm';
+import { v4 as uuid } from 'uuid';
+import {
+	alias,
+	boolean,
+	char,
+	cidr,
+	getMaterializedViewConfig,
+	getTableConfig,
+	getViewConfig,
+	inet,
+	integer,
+	jsonb,
+	macaddr,
+	macaddr8,
+	type PgColumn,
+	pgEnum,
+	pgMaterializedView,
+	pgTable,
+	pgTableCreator,
+	pgView,
+	serial,
+	text,
+	timestamp,
+	unique,
+	uniqueKeyName,
+	uuid as pgUuid,
+	varchar,
+} from 'drizzle-orm/pg-core';
+import pg from 'pg';
+import getPort from 'get-port';
+import { migrate } from 'drizzle-orm/pg-proxy/migrator';
+import { drizzle as proxyDrizzle } from 'drizzle-orm/pg-proxy';
+import type { PgRemoteDatabase } from 'drizzle-orm/pg-proxy';
+import type { Equal} from './utils.ts';
+import { Expect } from './utils.ts';
+
+// eslint-disable-next-line drizzle/require-entity-kind
+class ServerSimulator {
+	constructor(private db: pg.Client) {}
+
+	async query(sql: string, params: any[], method: 'all' | 'execute') {
+		if (method === 'all') {
+			try {
+				const result = await this.db.query({
+					text: sql,
+					values: params,
+					rowMode: 'array',
+				});
+
+				return { data: result.rows as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else if (method === 'execute') {
+			try {
+				const result = await this.db.query({
+					text: sql,
+					values: params,
+				});
+
+				return { data: result.rows as any };
+			} catch (e: any) {
+				return { error: e };
+			}
+		} else {
+			return { error: 'Unknown method value' };
+		}
+	}
+
+	async migrations(queries: string[]) {
+		await this.db.query('BEGIN');
+		try {
+			for (const query of queries) {
+				await this.db.query(query);
+			}
+			await this.db.query('COMMIT');
+		} catch {
+			await this.db.query('ROLLBACK');
+		}
+
+		return {};
+	}
+}
+
+const { Client } = pg;
+
+const ENABLE_LOGGING = false;
+
+const usersTable = pgTable('users', {
+	id: serial('id' as string).primaryKey(),
+	name: text('name').notNull(),
+	verified: boolean('verified').notNull().default(false),
+	jsonb: jsonb('jsonb').$type<string[]>(),
+	createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+const citiesTable = pgTable('cities', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	state: char('state', { length: 2 }),
+});
+
+const users2Table = pgTable('users2', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	cityId: integer('city_id').references(() => citiesTable.id),
+});
+
+const coursesTable = pgTable('courses', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	categoryId: integer('category_id').references(() => courseCategoriesTable.id),
+});
+
+const courseCategoriesTable = pgTable('course_categories', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+});
+
+const orders = pgTable('orders', {
+	id: serial('id').primaryKey(),
+	region: text('region').notNull(),
+	product: text('product').notNull().$default(() => 'random_string'),
+	amount: integer('amount').notNull(),
+	quantity: integer('quantity').notNull(),
+});
+
+const network = pgTable('network_table', {
+	inet: inet('inet').notNull(),
+	cidr: cidr('cidr').notNull(),
+	macaddr: macaddr('macaddr').notNull(),
+	macaddr8: macaddr8('macaddr8').notNull(),
+});
+
+const salEmp = pgTable('sal_emp', {
+	name: text('name'),
+	payByQuarter: integer('pay_by_quarter').array(),
+	schedule: text('schedule').array().array(),
+});
+
+const usersMigratorTable = pgTable('users12', {
+	id: serial('id').primaryKey(),
+	name: text('name').notNull(),
+	email: text('email').notNull(),
+});
+
+interface Context {
+	docker: Docker;
+	pgContainer: Docker.Container;
+	db: PgRemoteDatabase;
+	client: pg.Client;
+	serverSimulator: ServerSimulator;
+}
+
+const test = anyTest as TestFn<Context>;
+
+async function createDockerDB(ctx: Context): Promise<string> {
+	const docker = (ctx.docker = new Docker());
+	const port = await getPort({ port: 5432 });
+	const image = 'postgres:14';
+
+	const pullStream = await docker.pull(image);
+	await new Promise((resolve, reject) =>
+		docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
+	);
+
+	ctx.pgContainer = await docker.createContainer({
+		Image: image,
+		Env: ['POSTGRES_PASSWORD=postgres', 'POSTGRES_USER=postgres', 'POSTGRES_DB=postgres'],
+		name: `drizzle-integration-tests-${uuid()}`,
+		HostConfig: {
+			AutoRemove: true,
+			PortBindings: {
+				'5432/tcp': [{ HostPort: `${port}` }],
+			},
+		},
+	});
+
+	await ctx.pgContainer.start();
+
+	return `postgres://postgres:postgres@localhost:${port}/postgres`;
+}
+
+test.before(async (t) => {
+	const ctx = t.context;
+	const connectionString = process.env['PG_CONNECTION_STRING'] ?? (await createDockerDB(ctx));
+
+	const sleep = 250;
+	let timeLeft = 5000;
+	let connected = false;
+	let lastError: unknown | undefined;
+	do {
+		try {
+			ctx.client = new Client(connectionString);
+			await ctx.client.connect();
+			connected = true;
+			break;
+		} catch (e) {
+			lastError = e;
+			await new Promise((resolve) => setTimeout(resolve, sleep));
+			timeLeft -= sleep;
+		}
+	} while (timeLeft > 0);
+	if (!connected) {
+		console.error('Cannot connect to Postgres');
+		await ctx.client?.end().catch(console.error);
+		await ctx.pgContainer?.stop().catch(console.error);
+		throw lastError;
+	}
+
+	ctx.serverSimulator = new ServerSimulator(ctx.client);
+
+    ctx.db = proxyDrizzle(async (sql, params, method) => {
+		try {
+			const response = await ctx.serverSimulator.query(sql, params, method);
+
+			if (response.error !== undefined) {
+				throw response.error;
+			}
+
+			return { rows: response.data };
+		} catch (e: any) {
+			console.error('Error from pg proxy server:', e.message);
+			throw e;
+		}
+	}, {
+        logger: ENABLE_LOGGING
+    })
+});
+
+test.after.always(async (t) => {
+	const ctx = t.context;
+	await ctx.client?.end().catch(console.error);
+	await ctx.pgContainer?.stop().catch(console.error);
+});
+
+test.beforeEach(async (t) => {
+	const ctx = t.context;
+	await ctx.db.execute(sql`drop schema public cascade`);
+	await ctx.db.execute(sql`create schema public`);
+	await ctx.db.execute(
+		sql`
+			create table users (
+				id serial primary key,
+				name text not null,
+				verified boolean not null default false, 
+				jsonb jsonb,
+				created_at timestamptz not null default now()
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table cities (
+				id serial primary key,
+				name text not null,
+				state char(2)
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table users2 (
+				id serial primary key,
+				name text not null,
+				city_id integer references cities(id)
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table course_categories (
+				id serial primary key,
+				name text not null
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table courses (
+				id serial primary key,
+				name text not null,
+				category_id integer references course_categories(id)
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table orders (
+				id serial primary key,
+				region text not null,
+				product text not null,
+				amount integer not null,
+				quantity integer not null
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table network_table (
+				inet inet not null,
+				cidr cidr not null,
+				macaddr macaddr not null,
+				macaddr8 macaddr8 not null
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table sal_emp (
+				name text not null,
+				pay_by_quarter integer[] not null,
+				schedule text[][] not null
+			)
+		`,
+	);
+	await ctx.db.execute(
+		sql`
+			create table tictactoe (
+				squares integer[3][3] not null
+			)
+		`,
+	);
+});
+
+test.serial('table configs: unique third param', async (t) => {
+	const cities1Table = pgTable('cities1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		state: char('state', { length: 2 }),
+	}, (t) => ({
+		f: unique('custom_name').on(t.name, t.state).nullsNotDistinct(),
+		f1: unique('custom_name1').on(t.name, t.state),
+	}));
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	t.assert(tableConfig.uniqueConstraints.length === 2);
+
+	t.assert(tableConfig.uniqueConstraints[0]?.name === 'custom_name');
+	t.assert(tableConfig.uniqueConstraints[0]?.nullsNotDistinct);
+	t.deepEqual(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name), ['name', 'state']);
+
+	t.assert(tableConfig.uniqueConstraints[1]?.name, 'custom_name1');
+	t.assert(!tableConfig.uniqueConstraints[1]?.nullsNotDistinct);
+	t.deepEqual(tableConfig.uniqueConstraints[0]?.columns.map((t) => t.name), ['name', 'state']);
+});
+
+test.serial('table configs: unique in column', async (t) => {
+	const cities1Table = pgTable('cities1', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull().unique(),
+		state: char('state', { length: 2 }).unique('custom'),
+		field: char('field', { length: 2 }).unique('custom_field', { nulls: 'not distinct' }),
+	});
+
+	const tableConfig = getTableConfig(cities1Table);
+
+	const columnName = tableConfig.columns.find((it) => it.name === 'name');
+	t.assert(columnName?.uniqueName === uniqueKeyName(cities1Table, [columnName!.name]));
+	t.assert(columnName?.isUnique);
+
+	const columnState = tableConfig.columns.find((it) => it.name === 'state');
+	t.assert(columnState?.uniqueName === 'custom');
+	t.assert(columnState?.isUnique);
+
+	const columnField = tableConfig.columns.find((it) => it.name === 'field');
+	t.assert(columnField?.uniqueName === 'custom_field');
+	t.assert(columnField?.isUnique);
+	t.assert(columnField?.uniqueType === 'not distinct');
+});
+
+test.serial('select all fields', async (t) => {
+	const { db } = t.context;
+
+	const now = Date.now();
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+
+	t.assert(result[0]!.createdAt instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	t.assert(Math.abs(result[0]!.createdAt.getTime() - now) < 100);
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt },
+	]);
+});
+
+test.serial('select sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.select({
+			name: sql`upper(${usersTable.name})`,
+		})
+		.from(usersTable);
+
+	t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.serial('select typed sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+
+	const users = await db.select({
+		name: sql<string>`upper(${usersTable.name})`,
+	}).from(usersTable);
+
+	t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.serial('$default function', async (t) => {
+	const { db } = t.context;
+
+	const insertedOrder = await db.insert(orders).values({ id: 1, region: 'Ukraine', amount: 1, quantity: 1 })
+		.returning();
+	const selectedOrder = await db.select().from(orders);
+
+	t.deepEqual(insertedOrder, [{
+		id: 1,
+		amount: 1,
+		quantity: 1,
+		region: 'Ukraine',
+		product: 'random_string',
+	}]);
+
+	t.deepEqual(selectedOrder, [{
+		id: 1,
+		amount: 1,
+		quantity: 1,
+		region: 'Ukraine',
+		product: 'random_string',
+	}]);
+});
+
+test.serial('select distinct', async (t) => {
+	const { db } = t.context;
+
+	const usersDistinctTable = pgTable('users_distinct', {
+		id: integer('id').notNull(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${usersDistinctTable}`);
+	await db.execute(sql`create table ${usersDistinctTable} (id integer, name text)`);
+
+	await db.insert(usersDistinctTable).values([
+		{ id: 1, name: 'John' },
+		{ id: 1, name: 'John' },
+		{ id: 2, name: 'John' },
+		{ id: 1, name: 'Jane' },
+	]);
+	const users1 = await db.selectDistinct().from(usersDistinctTable).orderBy(
+		usersDistinctTable.id,
+		usersDistinctTable.name,
+	);
+	const users2 = await db.selectDistinctOn([usersDistinctTable.id]).from(usersDistinctTable).orderBy(
+		usersDistinctTable.id,
+	);
+	const users3 = await db.selectDistinctOn([usersDistinctTable.name], { name: usersDistinctTable.name }).from(
+		usersDistinctTable,
+	).orderBy(usersDistinctTable.name);
+
+	await db.execute(sql`drop table ${usersDistinctTable}`);
+
+	t.deepEqual(users1, [{ id: 1, name: 'Jane' }, { id: 1, name: 'John' }, { id: 2, name: 'John' }]);
+
+	t.deepEqual(users2.length, 2);
+	t.deepEqual(users2[0]?.id, 1);
+	t.deepEqual(users2[1]?.id, 2);
+
+	t.deepEqual(users3.length, 2);
+	t.deepEqual(users3[0]?.name, 'Jane');
+	t.deepEqual(users3[1]?.name, 'John');
+});
+
+test.serial('insert returning sql', async (t) => {
+	const { db } = t.context;
+
+	const users = await db
+		.insert(usersTable)
+		.values({ name: 'John' })
+		.returning({
+			name: sql`upper(${usersTable.name})`,
+		});
+
+	t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.serial('delete returning sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.delete(usersTable)
+		.where(eq(usersTable.name, 'John'))
+		.returning({
+			name: sql`upper(${usersTable.name})`,
+		});
+
+	t.deepEqual(users, [{ name: 'JOHN' }]);
+});
+
+test.serial('update returning sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.update(usersTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'))
+		.returning({
+			name: sql`upper(${usersTable.name})`,
+		});
+
+	t.deepEqual(users, [{ name: 'JANE' }]);
+});
+
+test.serial('update with returning all fields', async (t) => {
+	const { db } = t.context;
+
+	const now = Date.now();
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.update(usersTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'))
+		.returning();
+
+	t.assert(users[0]!.createdAt instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
+	t.deepEqual(users, [
+		{ id: 1, name: 'Jane', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
+	]);
+});
+
+test.serial('update with returning partial', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db
+		.update(usersTable)
+		.set({ name: 'Jane' })
+		.where(eq(usersTable.name, 'John'))
+		.returning({
+			id: usersTable.id,
+			name: usersTable.name,
+		});
+
+	t.deepEqual(users, [{ id: 1, name: 'Jane' }]);
+});
+
+test.serial('delete with returning all fields', async (t) => {
+	const { db } = t.context;
+
+	const now = Date.now();
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning();
+
+	t.assert(users[0]!.createdAt instanceof Date); // eslint-disable-line no-instanceof/no-instanceof
+	t.assert(Math.abs(users[0]!.createdAt.getTime() - now) < 100);
+	t.deepEqual(users, [
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: users[0]!.createdAt },
+	]);
+});
+
+test.serial('delete with returning partial', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const users = await db.delete(usersTable).where(eq(usersTable.name, 'John')).returning({
+		id: usersTable.id,
+		name: usersTable.name,
+	});
+
+	t.deepEqual(users, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('insert + select', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const result = await db.select().from(usersTable);
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result[0]!.createdAt },
+	]);
+
+	await db.insert(usersTable).values({ name: 'Jane' });
+	const result2 = await db.select().from(usersTable);
+	t.deepEqual(result2, [
+		{ id: 1, name: 'John', verified: false, jsonb: null, createdAt: result2[0]!.createdAt },
+		{ id: 2, name: 'Jane', verified: false, jsonb: null, createdAt: result2[1]!.createdAt },
+	]);
+});
+
+test.serial('json insert', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John', jsonb: ['foo', 'bar'] });
+	const result = await db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+		})
+		.from(usersTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'John', jsonb: ['foo', 'bar'] }]);
+});
+
+test.serial('char insert', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
+		.from(citiesTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'Austin', state: 'TX' }]);
+});
+
+test.serial('char update', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+	await db.update(citiesTable).set({ name: 'Atlanta', state: 'GA' }).where(eq(citiesTable.id, 1));
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
+		.from(citiesTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'Atlanta', state: 'GA' }]);
+});
+
+test.serial('char delete', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable).values({ name: 'Austin', state: 'TX' });
+	await db.delete(citiesTable).where(eq(citiesTable.state, 'TX'));
+	const result = await db
+		.select({ id: citiesTable.id, name: citiesTable.name, state: citiesTable.state })
+		.from(citiesTable);
+
+	t.deepEqual(result, []);
+});
+
+test.serial('insert with overridden default values', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John', verified: true });
+	const result = await db.select().from(usersTable);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', verified: true, jsonb: null, createdAt: result[0]!.createdAt },
+	]);
+});
+
+test.serial('insert many', async (t) => {
+	const { db } = t.context;
+
+	await db
+		.insert(usersTable)
+		.values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		]);
+	const result = await db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+			verified: usersTable.verified,
+		})
+		.from(usersTable);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test.serial('insert many with returning', async (t) => {
+	const { db } = t.context;
+
+	const result = await db
+		.insert(usersTable)
+		.values([
+			{ name: 'John' },
+			{ name: 'Bruce', jsonb: ['foo', 'bar'] },
+			{ name: 'Jane' },
+			{ name: 'Austin', verified: true },
+		])
+		.returning({
+			id: usersTable.id,
+			name: usersTable.name,
+			jsonb: usersTable.jsonb,
+			verified: usersTable.verified,
+		});
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', jsonb: null, verified: false },
+		{ id: 2, name: 'Bruce', jsonb: ['foo', 'bar'], verified: false },
+		{ id: 3, name: 'Jane', jsonb: null, verified: false },
+		{ id: 4, name: 'Austin', jsonb: null, verified: true },
+	]);
+});
+
+test.serial('select with group by as field', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.name);
+
+	t.deepEqual(result, [{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test.serial('select with group by as sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(sql`${usersTable.name}`);
+
+	t.deepEqual(result, [{ name: 'Jane' }, { name: 'John' }]);
+});
+
+test.serial('select with group by as sql + column', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(sql`${usersTable.name}`, usersTable.id);
+
+	t.deepEqual(result, [{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
+});
+
+test.serial('select with group by as column + sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`);
+
+	t.deepEqual(result, [{ name: 'Jane' }, { name: 'Jane' }, { name: 'John' }]);
+});
+
+test.serial('select with group by complex query', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }, { name: 'Jane' }]);
+
+	const result = await db
+		.select({ name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.id, sql`${usersTable.name}`)
+		.orderBy(asc(usersTable.name))
+		.limit(1);
+
+	t.deepEqual(result, [{ name: 'Jane' }]);
+});
+
+test.serial('build query', async (t) => {
+	const { db } = t.context;
+
+	const query = db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable)
+		.groupBy(usersTable.id, usersTable.name)
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql: 'select "id", "name" from "users" group by "users"."id", "users"."name"',
+		params: [],
+	});
+});
+
+test.serial('insert sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: sql`${'John'}` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('partial join with alias', async (t) => {
+	const { db } = t.context;
+	const customerAlias = alias(usersTable, 'customer');
+
+	await db.insert(usersTable).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select({
+			user: {
+				id: usersTable.id,
+				name: usersTable.name,
+			},
+			customer: {
+				id: customerAlias.id,
+				name: customerAlias.name,
+			},
+		})
+		.from(usersTable)
+		.leftJoin(customerAlias, eq(customerAlias.id, 11))
+		.where(eq(usersTable.id, 10));
+
+	t.deepEqual(result, [
+		{
+			user: { id: 10, name: 'Ivan' },
+			customer: { id: 11, name: 'Hans' },
+		},
+	]);
+});
+
+test.serial('full join with alias', async (t) => {
+	const { db } = t.context;
+
+	const pgTable = pgTableCreator((name) => `prefixed_${name}`);
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select()
+		.from(users)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(users.id, 10));
+
+	t.deepEqual(result, [{
+		users: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('select from alias', async (t) => {
+	const { db } = t.context;
+
+	const pgTable = pgTableCreator((name) => `prefixed_${name}`);
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`create table ${users} (id serial primary key, name text not null)`);
+
+	const user = alias(users, 'user');
+	const customers = alias(users, 'customer');
+
+	await db.insert(users).values([{ id: 10, name: 'Ivan' }, { id: 11, name: 'Hans' }]);
+	const result = await db
+		.select()
+		.from(user)
+		.leftJoin(customers, eq(customers.id, 11))
+		.where(eq(user.id, 10));
+
+	t.deepEqual(result, [{
+		user: {
+			id: 10,
+			name: 'Ivan',
+		},
+		customer: {
+			id: 11,
+			name: 'Hans',
+		},
+	}]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('insert with spaces', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: sql`'Jo   h     n'` });
+	const result = await db.select({ id: usersTable.id, name: usersTable.name }).from(usersTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'Jo   h     n' }]);
+});
+
+test.serial('prepared statement', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const statement = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.prepare('statement1');
+	const result = await statement.execute();
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('prepared statement reuse', async (t) => {
+	const { db } = t.context;
+
+	const stmt = db
+		.insert(usersTable)
+		.values({
+			verified: true,
+			name: placeholder('name'),
+		})
+		.prepare('stmt2');
+
+	for (let i = 0; i < 10; i++) {
+		await stmt.execute({ name: `John ${i}` });
+	}
+
+	const result = await db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+			verified: usersTable.verified,
+		})
+		.from(usersTable);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John 0', verified: true },
+		{ id: 2, name: 'John 1', verified: true },
+		{ id: 3, name: 'John 2', verified: true },
+		{ id: 4, name: 'John 3', verified: true },
+		{ id: 5, name: 'John 4', verified: true },
+		{ id: 6, name: 'John 5', verified: true },
+		{ id: 7, name: 'John 6', verified: true },
+		{ id: 8, name: 'John 7', verified: true },
+		{ id: 9, name: 'John 8', verified: true },
+		{ id: 10, name: 'John 9', verified: true },
+	]);
+});
+
+test.serial('prepared statement with placeholder in .where', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const stmt = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.where(eq(usersTable.id, placeholder('id')))
+		.prepare('stmt3');
+	const result = await stmt.execute({ id: 1 });
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('prepared statement with placeholder in .limit', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+	const stmt = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.where(eq(usersTable.id, placeholder('id')))
+		.limit(placeholder('limit'))
+		.prepare('stmt_limit');
+
+	const result = await stmt.execute({ id: 1, limit: 1 });
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+	t.is(result.length, 1);
+});
+
+test.serial('prepared statement with placeholder in .offset', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'John1' }]);
+	const stmt = db
+		.select({
+			id: usersTable.id,
+			name: usersTable.name,
+		})
+		.from(usersTable)
+		.offset(placeholder('offset'))
+		.prepare('stmt_offset');
+
+	const result = await stmt.execute({ offset: 1 });
+
+	t.deepEqual(result, [{ id: 2, name: 'John1' }]);
+});
+
+// TODO change tests to new structure
+test.serial('migrator', async (t) => {
+	const { db, serverSimulator } = t.context;
+
+	await db.execute(sql`drop table if exists all_columns`);
+	await db.execute(sql`drop table if exists users12`);
+	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
+	
+	await migrate(db, async (queries) => {
+		try {
+			await serverSimulator.migrations(queries);
+		} catch (e) {
+			console.error(e);
+			throw new Error('Proxy server cannot run migrations');
+		}
+	}, { migrationsFolder: './drizzle2/pg' });
+
+	await db.insert(usersMigratorTable).values({ name: 'John', email: 'email' });
+
+	const result = await db.select().from(usersMigratorTable);
+
+	t.deepEqual(result, [{ id: 1, name: 'John', email: 'email' }]);
+
+	await db.execute(sql`drop table all_columns`);
+	await db.execute(sql`drop table users12`);
+	await db.execute(sql`drop table "drizzle"."__drizzle_migrations"`);
+});
+
+test.serial('insert via db.execute + select via db.execute', async (t) => {
+	const { db } = t.context;
+
+	await db.execute(
+		sql`insert into ${usersTable} (${name(usersTable.name.name)}) values (${'John'})`,
+	);
+
+	const result = await db.execute<{ id: number; name: string }>(
+		sql`select id, name from "users"`,
+	);
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('insert via db.execute + returning', async (t) => {
+	const { db } = t.context;
+
+	const inserted = await db.execute<{ id: number; name: string }>(
+		sql`insert into ${usersTable} (${
+			name(
+				usersTable.name.name,
+			)
+		}) values (${'John'}) returning ${usersTable.id}, ${usersTable.name}`,
+	);
+	t.deepEqual(inserted, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('insert via db.execute w/ query builder', async (t) => {
+	const { db } = t.context;
+
+	const inserted = await db.execute<Pick<typeof usersTable.$inferSelect, 'id' | 'name'>>(
+		db
+			.insert(usersTable)
+			.values({ name: 'John' })
+			.returning({ id: usersTable.id, name: usersTable.name }),
+	);
+	t.deepEqual(inserted, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('Query check: Insert all defaults in 1 row', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	const query = db
+		.insert(users)
+		.values({})
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql: 'insert into "users" ("id", "name", "state") values (default, default, default)',
+		params: [],
+	});
+});
+
+test.serial('Query check: Insert all defaults in multiple rows', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state').default('UA'),
+	});
+
+	const query = db
+		.insert(users)
+		.values([{}, {}])
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql: 'insert into "users" ("id", "name", "state") values (default, default, default), (default, default, default)',
+		params: [],
+	});
+});
+
+test.serial('Insert all defaults in 1 row', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('empty_insert_single', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
+	);
+
+	await db.insert(users).values({});
+
+	const res = await db.select().from(users);
+
+	t.deepEqual(res, [{ id: 1, name: 'Dan', state: null }]);
+});
+
+test.serial('Insert all defaults in multiple rows', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('empty_insert_multiple', {
+		id: serial('id').primaryKey(),
+		name: text('name').default('Dan'),
+		state: text('state'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial primary key, name text default 'Dan', state text)`,
+	);
+
+	await db.insert(users).values([{}, {}]);
+
+	const res = await db.select().from(users);
+
+	t.deepEqual(res, [{ id: 1, name: 'Dan', state: null }, { id: 2, name: 'Dan', state: null }]);
+});
+
+test.serial('build query insert with onConflict do update', async (t) => {
+	const { db } = t.context;
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } })
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do update set "name" = $3',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test.serial('build query insert with onConflict do update / multiple columns', async (t) => {
+	const { db } = t.context;
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoUpdate({ target: [usersTable.id, usersTable.name], set: { name: 'John1' } })
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id","name") do update set "name" = $3',
+		params: ['John', '["foo","bar"]', 'John1'],
+	});
+});
+
+test.serial('build query insert with onConflict do nothing', async (t) => {
+	const { db } = t.context;
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoNothing()
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict do nothing',
+		params: ['John', '["foo","bar"]'],
+	});
+});
+
+test.serial('build query insert with onConflict do nothing + target', async (t) => {
+	const { db } = t.context;
+
+	const query = db
+		.insert(usersTable)
+		.values({ name: 'John', jsonb: ['foo', 'bar'] })
+		.onConflictDoNothing({ target: usersTable.id })
+		.toSQL();
+
+	t.deepEqual(query, {
+		sql:
+			'insert into "users" ("id", "name", "verified", "jsonb", "created_at") values (default, $1, default, $2, default) on conflict ("id") do nothing',
+		params: ['John', '["foo","bar"]'],
+	});
+});
+
+test.serial('insert with onConflict do update', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+
+	await db
+		.insert(usersTable)
+		.values({ id: 1, name: 'John' })
+		.onConflictDoUpdate({ target: usersTable.id, set: { name: 'John1' } });
+
+	const res = await db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable)
+		.where(eq(usersTable.id, 1));
+
+	t.deepEqual(res, [{ id: 1, name: 'John1' }]);
+});
+
+test.serial('insert with onConflict do nothing', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+
+	await db.insert(usersTable).values({ id: 1, name: 'John' }).onConflictDoNothing();
+
+	const res = await db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable)
+		.where(eq(usersTable.id, 1));
+
+	t.deepEqual(res, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('insert with onConflict do nothing + target', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values({ name: 'John' });
+
+	await db
+		.insert(usersTable)
+		.values({ id: 1, name: 'John' })
+		.onConflictDoNothing({ target: usersTable.id });
+
+	const res = await db
+		.select({ id: usersTable.id, name: usersTable.name })
+		.from(usersTable)
+		.where(eq(usersTable.id, 1));
+
+	t.deepEqual(res, [{ id: 1, name: 'John' }]);
+});
+
+test.serial('left join (flat object fields)', async (t) => {
+	const { db } = t.context;
+
+	const { id: cityId } = await db
+		.insert(citiesTable)
+		.values([{ name: 'Paris' }, { name: 'London' }])
+		.returning({ id: citiesTable.id })
+		.then((rows) => rows[0]!);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+	const res = await db
+		.select({
+			userId: users2Table.id,
+			userName: users2Table.name,
+			cityId: citiesTable.id,
+			cityName: citiesTable.name,
+		})
+		.from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	t.deepEqual(res, [
+		{ userId: 1, userName: 'John', cityId, cityName: 'Paris' },
+		{ userId: 2, userName: 'Jane', cityId: null, cityName: null },
+	]);
+});
+
+test.serial('left join (grouped fields)', async (t) => {
+	const { db } = t.context;
+
+	const { id: cityId } = await db
+		.insert(citiesTable)
+		.values([{ name: 'Paris' }, { name: 'London' }])
+		.returning({ id: citiesTable.id })
+		.then((rows) => rows[0]!);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+	const res = await db
+		.select({
+			id: users2Table.id,
+			user: {
+				name: users2Table.name,
+				nameUpper: sql<string>`upper(${users2Table.name})`,
+			},
+			city: {
+				id: citiesTable.id,
+				name: citiesTable.name,
+				nameUpper: sql<string>`upper(${citiesTable.name})`,
+			},
+		})
+		.from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	t.deepEqual(res, [
+		{
+			id: 1,
+			user: { name: 'John', nameUpper: 'JOHN' },
+			city: { id: cityId, name: 'Paris', nameUpper: 'PARIS' },
+		},
+		{
+			id: 2,
+			user: { name: 'Jane', nameUpper: 'JANE' },
+			city: null,
+		},
+	]);
+});
+
+test.serial('left join (all fields)', async (t) => {
+	const { db } = t.context;
+
+	const { id: cityId } = await db
+		.insert(citiesTable)
+		.values([{ name: 'Paris' }, { name: 'London' }])
+		.returning({ id: citiesTable.id })
+		.then((rows) => rows[0]!);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId }, { name: 'Jane' }]);
+
+	const res = await db
+		.select()
+		.from(users2Table)
+		.leftJoin(citiesTable, eq(users2Table.cityId, citiesTable.id));
+
+	t.deepEqual(res, [
+		{
+			users2: {
+				id: 1,
+				name: 'John',
+				cityId,
+			},
+			cities: {
+				id: cityId,
+				name: 'Paris',
+				state: null,
+			},
+		},
+		{
+			users2: {
+				id: 2,
+				name: 'Jane',
+				cityId: null,
+			},
+			cities: null,
+		},
+	]);
+});
+
+test.serial('join subquery', async (t) => {
+	const { db } = t.context;
+
+	await db
+		.insert(courseCategoriesTable)
+		.values([
+			{ name: 'Category 1' },
+			{ name: 'Category 2' },
+			{ name: 'Category 3' },
+			{ name: 'Category 4' },
+		]);
+
+	await db
+		.insert(coursesTable)
+		.values([
+			{ name: 'Development', categoryId: 2 },
+			{ name: 'IT & Software', categoryId: 3 },
+			{ name: 'Marketing', categoryId: 4 },
+			{ name: 'Design', categoryId: 1 },
+		]);
+
+	const sq2 = db
+		.select({
+			categoryId: courseCategoriesTable.id,
+			category: courseCategoriesTable.name,
+			total: sql<number>`count(${courseCategoriesTable.id})`,
+		})
+		.from(courseCategoriesTable)
+		.groupBy(courseCategoriesTable.id, courseCategoriesTable.name)
+		.as('sq2');
+
+	const res = await db
+		.select({
+			courseName: coursesTable.name,
+			categoryId: sq2.categoryId,
+		})
+		.from(coursesTable)
+		.leftJoin(sq2, eq(coursesTable.categoryId, sq2.categoryId))
+		.orderBy(coursesTable.name);
+
+	t.deepEqual(res, [
+		{ courseName: 'Design', categoryId: 1 },
+		{ courseName: 'Development', categoryId: 2 },
+		{ courseName: 'IT & Software', categoryId: 3 },
+		{ courseName: 'Marketing', categoryId: 4 },
+	]);
+});
+
+test.serial('with ... select', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(orders).values([
+		{ region: 'Europe', product: 'A', amount: 10, quantity: 1 },
+		{ region: 'Europe', product: 'A', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 20, quantity: 2 },
+		{ region: 'Europe', product: 'B', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 30, quantity: 3 },
+		{ region: 'US', product: 'A', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 40, quantity: 4 },
+		{ region: 'US', product: 'B', amount: 50, quantity: 5 },
+	]);
+
+	const regionalSales = db
+		.$with('regional_sales')
+		.as(
+			db
+				.select({
+					region: orders.region,
+					totalSales: sql<number>`sum(${orders.amount})`.as('total_sales'),
+				})
+				.from(orders)
+				.groupBy(orders.region),
+		);
+
+	const topRegions = db
+		.$with('top_regions')
+		.as(
+			db
+				.select({
+					region: regionalSales.region,
+				})
+				.from(regionalSales)
+				.where(
+					gt(
+						regionalSales.totalSales,
+						db.select({ sales: sql`sum(${regionalSales.totalSales})/10` }).from(regionalSales),
+					),
+				),
+		);
+
+	const result = await db
+		.with(regionalSales, topRegions)
+		.select({
+			region: orders.region,
+			product: orders.product,
+			productUnits: sql<number>`sum(${orders.quantity})::int`,
+			productSales: sql<number>`sum(${orders.amount})::int`,
+		})
+		.from(orders)
+		.where(inArray(orders.region, db.select({ region: topRegions.region }).from(topRegions)))
+		.groupBy(orders.region, orders.product)
+		.orderBy(orders.region, orders.product);
+
+	t.deepEqual(result, [
+		{
+			region: 'Europe',
+			product: 'A',
+			productUnits: 3,
+			productSales: 30,
+		},
+		{
+			region: 'Europe',
+			product: 'B',
+			productUnits: 5,
+			productSales: 50,
+		},
+		{
+			region: 'US',
+			product: 'A',
+			productUnits: 7,
+			productSales: 70,
+		},
+		{
+			region: 'US',
+			product: 'B',
+			productUnits: 9,
+			productSales: 90,
+		},
+	]);
+});
+
+test.serial('select from subquery sql', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(users2Table).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const sq = db
+		.select({ name: sql<string>`${users2Table.name} || ' modified'`.as('name') })
+		.from(users2Table)
+		.as('sq');
+
+	const res = await db.select({ name: sq.name }).from(sq);
+
+	t.deepEqual(res, [{ name: 'John modified' }, { name: 'Jane modified' }]);
+});
+
+test.serial('select a field without joining its table', (t) => {
+	const { db } = t.context;
+
+	t.throws(() => db.select({ name: users2Table.name }).from(usersTable).prepare('query'));
+});
+
+test.serial('select all fields from subquery without alias', (t) => {
+	const { db } = t.context;
+
+	const sq = db.$with('sq').as(db.select({ name: sql<string>`upper(${users2Table.name})` }).from(users2Table));
+
+	t.throws(() => db.select().from(sq).prepare('query'));
+});
+
+test.serial('select count()', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const res = await db.select({ count: sql`count(*)` }).from(usersTable);
+
+	t.deepEqual(res, [{ count: '2' }]);
+});
+
+test.serial('select count w/ custom mapper', async (t) => {
+	const { db } = t.context;
+
+	function count(value: PgColumn | SQLWrapper): SQL<number>;
+	function count(value: PgColumn | SQLWrapper, alias: string): SQL.Aliased<number>;
+	function count(value: PgColumn | SQLWrapper, alias?: string): SQL<number> | SQL.Aliased<number> {
+		const result = sql`count(${value})`.mapWith(Number);
+		if (!alias) {
+			return result;
+		}
+		return result.as(alias);
+	}
+
+	await db.insert(usersTable).values([{ name: 'John' }, { name: 'Jane' }]);
+
+	const res = await db.select({ count: count(sql`*`) }).from(usersTable);
+
+	t.deepEqual(res, [{ count: 2 }]);
+});
+
+test.serial('network types', async (t) => {
+	const { db } = t.context;
+
+	const value: typeof network.$inferSelect = {
+		inet: '127.0.0.1',
+		cidr: '192.168.100.128/25',
+		macaddr: '08:00:2b:01:02:03',
+		macaddr8: '08:00:2b:01:02:03:04:05',
+	};
+
+	await db.insert(network).values(value);
+
+	const res = await db.select().from(network);
+
+	t.deepEqual(res, [value]);
+});
+
+test.serial('array types', async (t) => {
+	const { db } = t.context;
+
+	const values: typeof salEmp.$inferSelect[] = [
+		{
+			name: 'John',
+			payByQuarter: [10000, 10000, 10000, 10000],
+			schedule: [['meeting', 'lunch'], ['training', 'presentation']],
+		},
+		{
+			name: 'Carol',
+			payByQuarter: [20000, 25000, 25000, 25000],
+			schedule: [['breakfast', 'consulting'], ['meeting', 'lunch']],
+		},
+	];
+
+	await db.insert(salEmp).values(values);
+
+	const res = await db.select().from(salEmp);
+
+	t.deepEqual(res, values);
+});
+
+test.serial('select for ...', (t) => {
+	const { db } = t.context;
+
+	const query = db
+		.select()
+		.from(users2Table)
+		.for('update')
+		.for('no key update', { of: users2Table })
+		.for('no key update', { of: users2Table, skipLocked: true })
+		.for('share', { of: users2Table, noWait: true })
+		.toSQL();
+
+	t.regex(
+		query.sql,
+		// eslint-disable-next-line unicorn/better-regex
+		/ for update for no key update of "users2" for no key update of "users2" skip locked for share of "users2" no wait$/,
+	);
+});
+
+test.serial('having', async (t) => {
+	const { db } = t.context;
+
+	await db.insert(citiesTable).values([{ name: 'London' }, { name: 'Paris' }, { name: 'New York' }]);
+
+	await db.insert(users2Table).values([{ name: 'John', cityId: 1 }, { name: 'Jane', cityId: 1 }, {
+		name: 'Jack',
+		cityId: 2,
+	}]);
+
+	const result = await db
+		.select({
+			id: citiesTable.id,
+			name: sql<string>`upper(${citiesTable.name})`.as('upper_name'),
+			usersCount: sql<number>`count(${users2Table.id})::int`.as('users_count'),
+		})
+		.from(citiesTable)
+		.leftJoin(users2Table, eq(users2Table.cityId, citiesTable.id))
+		.where(({ name }) => sql`length(${name}) >= 3`)
+		.groupBy(citiesTable.id)
+		.having(({ usersCount }) => sql`${usersCount} > 0`)
+		.orderBy(({ name }) => name);
+
+	t.deepEqual(result, [
+		{
+			id: 1,
+			name: 'LONDON',
+			usersCount: 2,
+		},
+		{
+			id: 2,
+			name: 'PARIS',
+			usersCount: 1,
+		},
+	]);
+});
+
+test.serial('view', async (t) => {
+	const { db } = t.context;
+
+	const newYorkers1 = pgView('new_yorkers')
+		.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+	const newYorkers2 = pgView('new_yorkers', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull(),
+	}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+	const newYorkers3 = pgView('new_yorkers', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull(),
+	}).existing();
+
+	await db.execute(sql`create view ${newYorkers1} as ${getViewConfig(newYorkers1).query}`);
+
+	await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+	await db.insert(users2Table).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 1 },
+		{ name: 'Jack', cityId: 2 },
+	]);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers2);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers3);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+		t.deepEqual(result, [
+			{ name: 'John' },
+			{ name: 'Jane' },
+		]);
+	}
+
+	await db.execute(sql`drop view ${newYorkers1}`);
+});
+
+test.serial('materialized view', async (t) => {
+	const { db } = t.context;
+
+	const newYorkers1 = pgMaterializedView('new_yorkers')
+		.as((qb) => qb.select().from(users2Table).where(eq(users2Table.cityId, 1)));
+
+	const newYorkers2 = pgMaterializedView('new_yorkers', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull(),
+	}).as(sql`select * from ${users2Table} where ${eq(users2Table.cityId, 1)}`);
+
+	const newYorkers3 = pgMaterializedView('new_yorkers', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull(),
+	}).existing();
+
+	await db.execute(sql`create materialized view ${newYorkers1} as ${getMaterializedViewConfig(newYorkers1).query}`);
+
+	await db.insert(citiesTable).values([{ name: 'New York' }, { name: 'Paris' }]);
+
+	await db.insert(users2Table).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 1 },
+		{ name: 'Jack', cityId: 2 },
+	]);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		t.deepEqual(result, []);
+	}
+
+	await db.refreshMaterializedView(newYorkers1);
+
+	{
+		const result = await db.select().from(newYorkers1);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers2);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select().from(newYorkers3);
+		t.deepEqual(result, [
+			{ id: 1, name: 'John', cityId: 1 },
+			{ id: 2, name: 'Jane', cityId: 1 },
+		]);
+	}
+
+	{
+		const result = await db.select({ name: newYorkers1.name }).from(newYorkers1);
+		t.deepEqual(result, [
+			{ name: 'John' },
+			{ name: 'Jane' },
+		]);
+	}
+
+	await db.execute(sql`drop materialized view ${newYorkers1}`);
+});
+
+// TODO: copy to SQLite and MySQL, add to docs
+test.serial('select from raw sql', async (t) => {
+	const { db } = t.context;
+
+	const result = await db.select({
+		id: sql<number>`id`,
+		name: sql<string>`name`,
+	}).from(sql`(select 1 as id, 'John' as name) as users`);
+
+	Expect<Equal<{ id: number; name: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John' },
+	]);
+});
+
+test.serial('select from raw sql with joins', async (t) => {
+	const { db } = t.context;
+
+	const result = await db
+		.select({
+			id: sql<number>`users.id`,
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, sql`cities.id = users.id`);
+
+	Expect<Equal<{ id: number; name: string; userCity: string; cityName: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', userCity: 'New York', cityName: 'Paris' },
+	]);
+});
+
+test.serial('join on aliased sql from select', async (t) => {
+	const { db } = t.context;
+
+	const result = await db
+		.select({
+			userId: sql<number>`users.id`.as('userId'),
+			name: sql<string>`users.name`,
+			userCity: sql<string>`users.city`,
+			cityId: sql<number>`cities.id`.as('cityId'),
+			cityName: sql<string>`cities.name`,
+		})
+		.from(sql`(select 1 as id, 'John' as name, 'New York' as city) as users`)
+		.leftJoin(sql`(select 1 as id, 'Paris' as name) as cities`, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test.serial('join on aliased sql from with clause', async (t) => {
+	const { db } = t.context;
+
+	const users = db.$with('users').as(
+		db.select({
+			id: sql<number>`id`.as('userId'),
+			name: sql<string>`name`.as('userName'),
+			city: sql<string>`city`.as('city'),
+		}).from(
+			sql`(select 1 as id, 'John' as name, 'New York' as city) as users`,
+		),
+	);
+
+	const cities = db.$with('cities').as(
+		db.select({
+			id: sql<number>`id`.as('cityId'),
+			name: sql<string>`name`.as('cityName'),
+		}).from(
+			sql`(select 1 as id, 'Paris' as name) as cities`,
+		),
+	);
+
+	const result = await db
+		.with(users, cities)
+		.select({
+			userId: users.id,
+			name: users.name,
+			userCity: users.city,
+			cityId: cities.id,
+			cityName: cities.name,
+		})
+		.from(users)
+		.leftJoin(cities, (cols) => eq(cols.cityId, cols.userId));
+
+	Expect<Equal<{ userId: number; name: string; userCity: string; cityId: number; cityName: string }[], typeof result>>;
+
+	t.deepEqual(result, [
+		{ userId: 1, name: 'John', userCity: 'New York', cityId: 1, cityName: 'Paris' },
+	]);
+});
+
+test.serial('prefixed table', async (t) => {
+	const { db } = t.context;
+
+	const pgTable = pgTableCreator((name) => `myprefix_${name}`);
+
+	const users = pgTable('test_prefixed_table_with_unique_name', {
+		id: integer('id').primaryKey(),
+		name: text('name').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table myprefix_test_prefixed_table_with_unique_name (id integer not null primary key, name text not null)`,
+	);
+
+	await db.insert(users).values({ id: 1, name: 'John' });
+
+	const result = await db.select().from(users);
+
+	t.deepEqual(result, [{ id: 1, name: 'John' }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('select from enum', async (t) => {
+	const { db } = t.context;
+
+	const muscleEnum = pgEnum('muscle', [
+		'abdominals',
+		'hamstrings',
+		'adductors',
+		'quadriceps',
+		'biceps',
+		'shoulders',
+		'chest',
+		'middle_back',
+		'calves',
+		'glutes',
+		'lower_back',
+		'lats',
+		'triceps',
+		'traps',
+		'forearms',
+		'neck',
+		'abductors',
+	]);
+
+	const forceEnum = pgEnum('force', ['isometric', 'isotonic', 'isokinetic']);
+
+	const levelEnum = pgEnum('level', ['beginner', 'intermediate', 'advanced']);
+
+	const mechanicEnum = pgEnum('mechanic', ['compound', 'isolation']);
+
+	const equipmentEnum = pgEnum('equipment', ['barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell']);
+
+	const categoryEnum = pgEnum('category', ['upper_body', 'lower_body', 'full_body']);
+
+	const exercises = pgTable('exercises', {
+		id: serial('id').primaryKey(),
+		name: varchar('name').notNull(),
+		force: forceEnum('force'),
+		level: levelEnum('level'),
+		mechanic: mechanicEnum('mechanic'),
+		equipment: equipmentEnum('equipment'),
+		instructions: text('instructions'),
+		category: categoryEnum('category'),
+		primaryMuscles: muscleEnum('primary_muscles').array(),
+		secondaryMuscles: muscleEnum('secondary_muscles').array(),
+		createdAt: timestamp('created_at').notNull().default(sql`now()`),
+		updatedAt: timestamp('updated_at').notNull().default(sql`now()`),
+	});
+
+	await db.execute(sql`drop table if exists ${exercises}`);
+	await db.execute(sql`drop type if exists ${name(muscleEnum.enumName)}`);
+	await db.execute(sql`drop type if exists ${name(forceEnum.enumName)}`);
+	await db.execute(sql`drop type if exists ${name(levelEnum.enumName)}`);
+	await db.execute(sql`drop type if exists ${name(mechanicEnum.enumName)}`);
+	await db.execute(sql`drop type if exists ${name(equipmentEnum.enumName)}`);
+	await db.execute(sql`drop type if exists ${name(categoryEnum.enumName)}`);
+
+	await db.execute(
+		sql`create type ${
+			name(muscleEnum.enumName)
+		} as enum ('abdominals', 'hamstrings', 'adductors', 'quadriceps', 'biceps', 'shoulders', 'chest', 'middle_back', 'calves', 'glutes', 'lower_back', 'lats', 'triceps', 'traps', 'forearms', 'neck', 'abductors')`,
+	);
+	await db.execute(sql`create type ${name(forceEnum.enumName)} as enum ('isometric', 'isotonic', 'isokinetic')`);
+	await db.execute(sql`create type ${name(levelEnum.enumName)} as enum ('beginner', 'intermediate', 'advanced')`);
+	await db.execute(sql`create type ${name(mechanicEnum.enumName)} as enum ('compound', 'isolation')`);
+	await db.execute(
+		sql`create type ${
+			name(equipmentEnum.enumName)
+		} as enum ('barbell', 'dumbbell', 'bodyweight', 'machine', 'cable', 'kettlebell')`,
+	);
+	await db.execute(sql`create type ${name(categoryEnum.enumName)} as enum ('upper_body', 'lower_body', 'full_body')`);
+	await db.execute(sql`
+		create table ${exercises} (
+			id serial primary key,
+			name varchar not null,
+			force force,
+			level level,
+			mechanic mechanic,
+			equipment equipment,
+			instructions text,
+			category category,
+			primary_muscles muscle[],
+			secondary_muscles muscle[],
+			created_at timestamp not null default now(),
+			updated_at timestamp not null default now()
+		)
+	`);
+
+	await db.insert(exercises).values({
+		name: 'Bench Press',
+		force: 'isotonic',
+		level: 'beginner',
+		mechanic: 'compound',
+		equipment: 'barbell',
+		instructions:
+			'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+		category: 'upper_body',
+		primaryMuscles: ['chest', 'triceps'],
+		secondaryMuscles: ['shoulders', 'traps'],
+	});
+
+	const result = await db.select().from(exercises);
+
+	t.deepEqual(result, [
+		{
+			id: 1,
+			name: 'Bench Press',
+			force: 'isotonic',
+			level: 'beginner',
+			mechanic: 'compound',
+			equipment: 'barbell',
+			instructions:
+				'Lie on your back on a flat bench. Grasp the barbell with an overhand grip, slightly wider than shoulder width. Unrack the barbell and hold it over you with your arms locked. Lower the barbell to your chest. Press the barbell back to the starting position.',
+			category: 'upper_body',
+			primaryMuscles: ['chest', 'triceps'],
+			secondaryMuscles: ['shoulders', 'traps'],
+			createdAt: result[0]!.createdAt,
+			updatedAt: result[0]!.updatedAt,
+		},
+	]);
+
+	await db.execute(sql`drop table ${exercises}`);
+	await db.execute(sql`drop type ${name(muscleEnum.enumName)}`);
+	await db.execute(sql`drop type ${name(forceEnum.enumName)}`);
+	await db.execute(sql`drop type ${name(levelEnum.enumName)}`);
+	await db.execute(sql`drop type ${name(mechanicEnum.enumName)}`);
+	await db.execute(sql`drop type ${name(equipmentEnum.enumName)}`);
+	await db.execute(sql`drop type ${name(categoryEnum.enumName)}`);
+});
+
+test.serial('orderBy with aliased column', (t) => {
+	const { db } = t.context;
+
+	const query = db.select({
+		test: sql`something`.as('test'),
+	}).from(users2Table).orderBy((fields) => fields.test).toSQL();
+
+	t.deepEqual(query.sql, 'select something as "test" from "users2" order by "test"');
+});
+
+test.serial('select from sql', async (t) => {
+	const { db } = t.context;
+
+	const metricEntry = pgTable('metric_entry', {
+		id: pgUuid('id').notNull(),
+		createdAt: timestamp('created_at').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${metricEntry}`);
+	await db.execute(sql`create table ${metricEntry} (id uuid not null, created_at timestamp not null)`);
+
+	const metricId = uuid();
+
+	const intervals = db.$with('intervals').as(
+		db
+			.select({
+				startTime: sql<string>`(date'2023-03-01'+ x * '1 day'::interval)`.as('start_time'),
+				endTime: sql<string>`(date'2023-03-01'+ (x+1) *'1 day'::interval)`.as('end_time'),
+			})
+			.from(sql`generate_series(0, 29, 1) as t(x)`),
+	);
+
+	await t.notThrowsAsync(() =>
+		db
+			.with(intervals)
+			.select({
+				startTime: intervals.startTime,
+				endTime: intervals.endTime,
+				count: sql<number>`count(${metricEntry})`,
+			})
+			.from(metricEntry)
+			.rightJoin(
+				intervals,
+				and(
+					eq(metricEntry.id, metricId),
+					gte(metricEntry.createdAt, intervals.startTime),
+					lt(metricEntry.createdAt, intervals.endTime),
+				),
+			)
+			.groupBy(intervals.startTime, intervals.endTime)
+			.orderBy(asc(intervals.startTime))
+	);
+});
+
+test.serial('timestamp timezone', async (t) => {
+	const { db } = t.context;
+
+	const usersTableWithAndWithoutTimezone = pgTable('users_test_with_and_without_timezone', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+		updatedAt: timestamp('updated_at', { withTimezone: false }).notNull().defaultNow(),
+	});
+
+	await db.execute(sql`drop table if exists ${usersTableWithAndWithoutTimezone}`);
+
+	await db.execute(
+		sql`
+			create table users_test_with_and_without_timezone (
+				id serial not null primary key,
+				name text not null,
+				created_at timestamptz not null default now(),
+				updated_at timestamp not null default now()
+			)
+		`,
+	);
+
+	const date = new Date(Date.parse('2020-01-01T00:00:00+04:00'));
+
+	await db.insert(usersTableWithAndWithoutTimezone).values({ name: 'With default times' });
+	await db.insert(usersTableWithAndWithoutTimezone).values({
+		name: 'Without default times',
+		createdAt: date,
+		updatedAt: date,
+	});
+	const users = await db.select().from(usersTableWithAndWithoutTimezone);
+
+	// check that the timestamps are set correctly for default times
+	t.assert(Math.abs(users[0]!.updatedAt.getTime() - Date.now()) < 2000);
+	t.assert(Math.abs(users[0]!.createdAt.getTime() - Date.now()) < 2000);
+
+	// check that the timestamps are set correctly for non default times
+	t.assert(Math.abs(users[1]!.updatedAt.getTime() - date.getTime()) < 2000);
+	t.assert(Math.abs(users[1]!.createdAt.getTime() - date.getTime()) < 2000);
+});
+
+// TODO: implement transaction
+// test.serial('transaction', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = pgTable('users_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+// 	const products = pgTable('products_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		price: integer('price').notNull(),
+// 		stock: integer('stock').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+// 	await db.execute(sql`drop table if exists ${products}`);
+
+// 	await db.execute(sql`create table users_transactions (id serial not null primary key, balance integer not null)`);
+// 	await db.execute(
+// 		sql`create table products_transactions (id serial not null primary key, price integer not null, stock integer not null)`,
+// 	);
+
+// 	const user = await db.insert(users).values({ balance: 100 }).returning().then((rows) => rows[0]!);
+// 	const product = await db.insert(products).values({ price: 10, stock: 10 }).returning().then((rows) => rows[0]!);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.update(users).set({ balance: user.balance - product.price }).where(eq(users.id, user.id));
+// 		await tx.update(products).set({ stock: product.stock - 1 }).where(eq(products.id, product.id));
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, [{ id: 1, balance: 90 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// 	await db.execute(sql`drop table ${products}`);
+// });
+
+// TODO: implement transaction
+// test.serial('transaction rollback', async (t) => {
+
+// 	const { db } = t.context;
+
+// 	const users = pgTable('users_transactions_rollback', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_transactions_rollback (id serial not null primary key, balance integer not null)`,
+// 	);
+
+// 	await t.throwsAsync(async () =>
+// 		await db.transaction(async (tx) => {
+// 			await tx.insert(users).values({ balance: 100 });
+// 			tx.rollback();
+// 		}), new TransactionRollbackError());
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, []);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// TODO: implement transaction
+// test.serial('nested transaction', async (t) => {
+// 	const { db } = t.context;
+
+// 	const users = pgTable('users_nested_transactions', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_nested_transactions (id serial not null primary key, balance integer not null)`,
+// 	);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.insert(users).values({ balance: 100 });
+
+// 		await tx.transaction(async (tx) => {
+// 			await tx.update(users).set({ balance: 200 });
+// 		});
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, [{ id: 1, balance: 200 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+// TODO: implement transaction
+// test.serial('nested transaction rollback', async (_t) => {
+// 	const { db } = t.context;
+
+// 	const users = pgTable('users_nested_transactions_rollback', {
+// 		id: serial('id').primaryKey(),
+// 		balance: integer('balance').notNull(),
+// 	});
+
+// 	await db.execute(sql`drop table if exists ${users}`);
+
+// 	await db.execute(
+// 		sql`create table users_nested_transactions_rollback (id serial not null primary key, balance integer not null)`,
+// 	);
+
+// 	await db.transaction(async (tx) => {
+// 		await tx.insert(users).values({ balance: 100 });
+
+// 		await t.throwsAsync(async () =>
+// 			await tx.transaction(async (tx) => {
+// 				await tx.update(users).set({ balance: 200 });
+// 				tx.rollback();
+// 			}), new TransactionRollbackError());
+// 	});
+
+// 	const result = await db.select().from(users);
+
+// 	t.deepEqual(result, [{ id: 1, balance: 100 }]);
+
+// 	await db.execute(sql`drop table ${users}`);
+// });
+
+test.serial('join subquery with join', async (t) => {
+	const { db } = t.context;
+
+	const internalStaff = pgTable('internal_staff', {
+		userId: integer('user_id').notNull(),
+	});
+
+	const customUser = pgTable('custom_user', {
+		id: integer('id').notNull(),
+	});
+
+	const ticket = pgTable('ticket', {
+		staffId: integer('staff_id').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${internalStaff}`);
+	await db.execute(sql`drop table if exists ${customUser}`);
+	await db.execute(sql`drop table if exists ${ticket}`);
+
+	await db.execute(sql`create table internal_staff (user_id integer not null)`);
+	await db.execute(sql`create table custom_user (id integer not null)`);
+	await db.execute(sql`create table ticket (staff_id integer not null)`);
+
+	await db.insert(internalStaff).values({ userId: 1 });
+	await db.insert(customUser).values({ id: 1 });
+	await db.insert(ticket).values({ staffId: 1 });
+
+	const subq = db
+		.select()
+		.from(internalStaff)
+		.leftJoin(customUser, eq(internalStaff.userId, customUser.id))
+		.as('internal_staff');
+
+	const mainQuery = await db
+		.select()
+		.from(ticket)
+		.leftJoin(subq, eq(subq.internal_staff.userId, ticket.staffId));
+
+	t.deepEqual(mainQuery, [{
+		ticket: { staffId: 1 },
+		internal_staff: {
+			internal_staff: { userId: 1 },
+			custom_user: { id: 1 },
+		},
+	}]);
+
+	await db.execute(sql`drop table ${internalStaff}`);
+	await db.execute(sql`drop table ${customUser}`);
+	await db.execute(sql`drop table ${ticket}`);
+});
+
+test.serial('subquery with view', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users_subquery_view', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull(),
+	});
+
+	const newYorkers = pgView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.$with('sq').as(db.select().from(newYorkers));
+	const result = await db.with(sq).select().from(sq);
+
+	t.deepEqual(result, [
+		{ id: 1, name: 'John', cityId: 1 },
+		{ id: 3, name: 'Jack', cityId: 1 },
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('join view as subquery', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users_join_view', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull(),
+	});
+
+	const newYorkers = pgView('new_yorkers').as((qb) => qb.select().from(users).where(eq(users.cityId, 1)));
+
+	await db.execute(sql`drop table if exists ${users}`);
+	await db.execute(sql`drop view if exists ${newYorkers}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+	);
+	await db.execute(sql`create view ${newYorkers} as select * from ${users} where city_id = 1`);
+
+	await db.insert(users).values([
+		{ name: 'John', cityId: 1 },
+		{ name: 'Jane', cityId: 2 },
+		{ name: 'Jack', cityId: 1 },
+		{ name: 'Jill', cityId: 2 },
+	]);
+
+	const sq = db.select().from(newYorkers).as('new_yorkers_sq');
+
+	const result = await db.select().from(users).leftJoin(sq, eq(users.id, sq.id));
+
+	t.deepEqual(result, [
+		{
+			users_join_view: { id: 1, name: 'John', cityId: 1 },
+			new_yorkers_sq: { id: 1, name: 'John', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 2, name: 'Jane', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+		{
+			users_join_view: { id: 3, name: 'Jack', cityId: 1 },
+			new_yorkers_sq: { id: 3, name: 'Jack', cityId: 1 },
+		},
+		{
+			users_join_view: { id: 4, name: 'Jill', cityId: 2 },
+			new_yorkers_sq: null,
+		},
+	]);
+
+	await db.execute(sql`drop view ${newYorkers}`);
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('table selection with single table', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name').notNull(),
+		cityId: integer('city_id').notNull(),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text not null, city_id integer not null)`,
+	);
+
+	await db.insert(users).values({ name: 'John', cityId: 1 });
+
+	const result = await db.select({ users }).from(users);
+
+	t.deepEqual(result, [{ users: { id: 1, name: 'John', cityId: 1 } }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('set null to jsonb field', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		jsonb: jsonb('jsonb'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, jsonb jsonb)`,
+	);
+
+	const result = await db.insert(users).values({ jsonb: null }).returning();
+
+	t.deepEqual(result, [{ id: 1, jsonb: null }]);
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('insert undefined', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text)`,
+	);
+
+	await t.notThrowsAsync(async () => await db.insert(users).values({ name: undefined }));
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('update undefined', async (t) => {
+	const { db } = t.context;
+
+	const users = pgTable('users', {
+		id: serial('id').primaryKey(),
+		name: text('name'),
+	});
+
+	await db.execute(sql`drop table if exists ${users}`);
+
+	await db.execute(
+		sql`create table ${users} (id serial not null primary key, name text)`,
+	);
+
+	await t.throwsAsync(async () => await db.update(users).set({ name: undefined }));
+	await t.notThrowsAsync(async () => await db.update(users).set({ id: 1, name: undefined }));
+
+	await db.execute(sql`drop table ${users}`);
+});
+
+test.serial('array operators', async (t) => {
+	const { db } = t.context;
+
+	const posts = pgTable('posts', {
+		id: serial('id').primaryKey(),
+		tags: text('tags').array()
+	});
+
+	await db.execute(sql`drop table if exists ${posts}`);
+
+	await db.execute(
+		sql`create table ${posts} (id serial primary key, tags text[])`,
+	);
+
+	await db.insert(posts).values([{
+		tags: ['ORM']
+	}, {
+		tags: ['Typescript']
+	}, {
+		tags: ['Typescript', 'ORM']
+	}, {
+		tags: ['Typescript', 'Frontend', 'React']
+	}, {
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+	}, {
+		tags: ['Java', 'Spring', 'OOP']
+	}]);
+
+	const contains = await db.select({ id: posts.id }).from(posts)
+		.where(arrayContains(posts.tags, ['Typescript', 'ORM']));
+	const contained = await db.select({ id: posts.id }).from(posts)
+		.where(arrayContained(posts.tags, ['Typescript', 'ORM']));
+	const overlaps = await db.select({ id: posts.id }).from(posts)
+		.where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']));
+	const withSubQuery = await db.select({ id: posts.id }).from(posts)
+		.where(arrayContains(
+			posts.tags,
+			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+		));
+
+	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
+	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
+	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+});

From d1d16d95d99403171728ebb3a61852813856c1a7 Mon Sep 17 00:00:00 2001
From: Roman <nabukhotnyiroman@gmail.com>
Date: Mon, 2 Oct 2023 10:55:04 +0300
Subject: [PATCH 34/72] fix: Remove test.ts

---
 integration-tests/test.ts | 204 --------------------------------------
 1 file changed, 204 deletions(-)
 delete mode 100644 integration-tests/test.ts

diff --git a/integration-tests/test.ts b/integration-tests/test.ts
deleted file mode 100644
index e6fced387..000000000
--- a/integration-tests/test.ts
+++ /dev/null
@@ -1,204 +0,0 @@
-import { sql } from 'drizzle-orm';
-// import { mysqlTable, serial, text } from 'drizzle-orm/mysql-core';
-import { drizzle } from 'drizzle-orm/mysql-proxy';
-// import postgres from "pg";
-import * as mysql from 'mysql2/promise';
-// import Docker from 'dockerode';
-// import getPort from 'get-port';
-// import { v4 as uuid } from 'uuid';
-
-
-// const pg = new postgres.Client("postgres://k6:k6@localhost:5432/northwind")
-
-async function createDockerDB(): Promise<string> {
-	// const docker = new Docker();
-	// const port = await getPort({ port: 3306 });
-	// const image = 'mysql:8';
-
-	// const pullStream = await docker.pull(image);
-	// await new Promise((resolve, reject) =>
-	// 	docker.modem.followProgress(pullStream, (err) => (err ? reject(err) : resolve(err)))
-	// );
-
-	// const container = await docker.createContainer({
-	// 	Image: image,
-	// 	Env: ['MYSQL_ROOT_PASSWORD=mysql', 'MYSQL_DATABASE=drizzle'],
-	// 	name: `drizzle-integration-tests-${uuid()}`,
-	// 	HostConfig: {
-	// 		AutoRemove: true,
-	// 		PortBindings: {
-	// 			'3306/tcp': [{ HostPort: `${port}` }],
-	// 		},
-	// 	},
-	// });
-
-	// await container.start();
-
-	return `mysql://root:mysql@127.0.0.1:3306/drizzle`;
-}
-
-const url = await createDockerDB();
-
-console.log(url)
-
-const client = await mysql.createConnection(url);
-
-// eslint-disable-next-line drizzle/require-entity-kind
-class ServerSimulator {
-	constructor(private db: mysql.Connection) {}
-
-	async query(sql: string, params: any[], method: 'all' | 'execute') {
-		if (method === 'all') {
-			try {
-				const result = await this.db.query({
-                    sql,
-                    values: params,
-					rowsAsArray: true,
-                    typeCast: function(field: any, next: any) {
-                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-                            return field.string();
-                        }
-                        return next();
-                    },
-                });
-
-				return { data: result[0] as any };
-			} catch (e: any) {
-				return { error: e.message };
-			}
-		} else if (method === 'execute') {
-			try {
-				const result = await this.db.query({
-                    sql,
-                    values: params,
-                    typeCast: function(field: any, next: any) {
-                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-                            return field.string();
-                        }
-                        return next();
-                    },
-				});
-
-				return { data: result[0] as any };
-			} catch (e: any) {
-				return { error: e.message };
-			}
-		} else {
-			return { error: 'Unknown method value' };
-		}
-	}
-
-	async migrations(queries: string[]) {
-		await this.db.query('BEGIN');
-		try {
-			for (const query of queries) {
-				await this.db.query(query);
-			}
-			await this.db.query('COMMIT');
-		} catch {
-			await this.db.query('ROLLBACK');
-		}
-
-		return {};
-	}
-}
-
-// const user = pgTable("customers", {
-//     id: text("customerid"),
-//     companyname: text("companyname")
-// })
-
-const serverSimulator = new ServerSimulator(client);
-
-const db = drizzle(async (sql, params, method) => {
-    try {
-        const response = await serverSimulator.query(sql, params, method);
-
-        if (response.error !== undefined) {
-            throw new Error(response.error);
-        }
-
-		console.log('response', response)
-
-        return { rows: response.data };
-    } catch (e: any) {
-        console.error('Error from pg proxy server:', e.message);
-        throw e;
-    }
-})
-
-// const usersMigratorTable = pgTable('users12', {
-// 	id: serial('id').primaryKey(),
-// 	name: text('name').notNull(),
-// 	email: text('email').notNull(),
-// });
-
-// const citiesTable = mysqlTable('cities', {
-// 	id: serial('id').primaryKey(),
-// 	name: text('name').notNull(),
-// });
-
-const main = async()=>{
-    // await db.execute(
-	// 	sql`insert into ${usersTable} (${name(usersTable.name.name)}) values (${'John'})`,
-	// );
-
-	// await db.execute(sql`
-	// 	create table if not exist \`cities\` (
-	// 		\`id\` serial primary key,
-	// 		\`name\` text not null
-	// 	)
-	// `,)
-
-	// await db.insert(citiesTable).values({
-	// 	name: 'New York',
-	// });
-
-	// const result = await db.execute<{ customerid: string }>(
-	// 	sql`select * from cities`,
-	// );
-
-    // console.log('result', result)
-
-	// const res = await db.select().from(citiesTable);
-
-	// console.log('res', res)
-
-	await db.execute(sql`drop table if exists \`userstest\``);
-	await db.execute(sql`drop table if exists \`users2\``);
-	await db.execute(sql`drop table if exists \`cities\``);
-
-	await db.execute(
-		sql`
-			create table \`userstest\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`verified\` boolean not null default false,
-				\`jsonb\` json,
-				\`created_at\` timestamp not null default now()
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`users2\` (
-				\`id\` serial primary key,
-				\`name\` text not null,
-				\`city_id\` int references \`cities\`(\`id\`)
-			)
-		`,
-	);
-
-	await db.execute(
-		sql`
-			create table \`cities\` (
-				\`id\` serial primary key,
-				\`name\` text not null
-			)
-		`,
-	);
-}
-
-main()
-

From 968ee62b2bc3348285af3a68ca94a4c39bed709a Mon Sep 17 00:00:00 2001
From: Roman <nabukhotnyiroman@gmail.com>
Date: Wed, 4 Oct 2023 12:45:53 +0300
Subject: [PATCH 35/72] fix: Fix pg and mysql proxy examples

---
 examples/mysql-proxy/package-lock.json | 12 ++++++++++++
 examples/mysql-proxy/package.json      |  1 +
 examples/mysql-proxy/src/server.ts     | 13 ++++++++++++-
 examples/pg-proxy/package-lock.json    | 12 ++++++++++++
 examples/pg-proxy/package.json         |  2 +-
 examples/pg-proxy/src/server.ts        | 13 ++++++++++++-
 6 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/examples/mysql-proxy/package-lock.json b/examples/mysql-proxy/package-lock.json
index 78c4c413d..0efb375d2 100644
--- a/examples/mysql-proxy/package-lock.json
+++ b/examples/mysql-proxy/package-lock.json
@@ -11,6 +11,7 @@
       "dependencies": {
         "axios": "^1.5.1",
         "express": "^4.18.2",
+        "express-rate-limit": "^7.0.2",
         "mysql2": "^3.6.1"
       },
       "devDependencies": {
@@ -975,6 +976,17 @@
         "node": ">= 0.10.0"
       }
     },
+    "node_modules/express-rate-limit": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.0.2.tgz",
+      "integrity": "sha512-EZoojG9civtJ6GRR7vE0JErow5q/ltbIl0RGbYhrNJKwBC9/kp2HckpdAvQkkE0sRAAtFDBvILvwZSR2kQroDw==",
+      "engines": {
+        "node": ">= 16"
+      },
+      "peerDependencies": {
+        "express": "^4 || ^5"
+      }
+    },
     "node_modules/ext": {
       "version": "1.7.0",
       "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
diff --git a/examples/mysql-proxy/package.json b/examples/mysql-proxy/package.json
index 5ca080f85..5f1104180 100644
--- a/examples/mysql-proxy/package.json
+++ b/examples/mysql-proxy/package.json
@@ -14,6 +14,7 @@
   "dependencies": {
     "axios": "^1.5.1",
     "express": "^4.18.2",
+    "express-rate-limit": "^7.0.2",
     "mysql2": "^3.6.1"
   },
   "devDependencies": {
diff --git a/examples/mysql-proxy/src/server.ts b/examples/mysql-proxy/src/server.ts
index 42a7687b2..98842f4c0 100644
--- a/examples/mysql-proxy/src/server.ts
+++ b/examples/mysql-proxy/src/server.ts
@@ -1,15 +1,26 @@
 import * as mysql from 'mysql2/promise';
 import express from 'express';
+import RateLimit from 'express-rate-limit';
 
 const app = express();
+
+const limiter = RateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100, // max 100 requests per windowMs
+});
+
 app.use(express.json());
+app.use(limiter);
 const port = 3000;
 
 const main = async () => {
 const connection = await mysql.createConnection('mysql://root:mysql@127.0.0.1:5432/drizzle');
 
 app.post('/query', async (req, res) => {
-	const { sql: sqlBody, params, method } = req.body;
+	const { sql, params, method } = req.body;
+
+    // prevent multiple queries
+	const sqlBody = sql.replace(/;/g, '');
 
 	if (method === 'all') {
 		try {
diff --git a/examples/pg-proxy/package-lock.json b/examples/pg-proxy/package-lock.json
index 58554f5f9..794f959b9 100644
--- a/examples/pg-proxy/package-lock.json
+++ b/examples/pg-proxy/package-lock.json
@@ -11,6 +11,7 @@
       "dependencies": {
         "axios": "^1.5.1",
         "express": "^4.18.2",
+        "express-rate-limit": "^7.0.2",
         "pg": "^8.11.3"
       },
       "devDependencies": {
@@ -1044,6 +1045,17 @@
         "node": ">= 0.10.0"
       }
     },
+    "node_modules/express-rate-limit": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.0.2.tgz",
+      "integrity": "sha512-EZoojG9civtJ6GRR7vE0JErow5q/ltbIl0RGbYhrNJKwBC9/kp2HckpdAvQkkE0sRAAtFDBvILvwZSR2kQroDw==",
+      "engines": {
+        "node": ">= 16"
+      },
+      "peerDependencies": {
+        "express": "^4 || ^5"
+      }
+    },
     "node_modules/ext": {
       "version": "1.7.0",
       "resolved": "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz",
diff --git a/examples/pg-proxy/package.json b/examples/pg-proxy/package.json
index f947baf74..20a049c9b 100644
--- a/examples/pg-proxy/package.json
+++ b/examples/pg-proxy/package.json
@@ -14,7 +14,7 @@
   "dependencies": {
     "axios": "^1.5.1",
     "express": "^4.18.2",
-    "drizzle-orm": "workspace:../../drizzle-orm/dist",
+    "express-rate-limit": "^7.0.2",
     "pg": "^8.11.3"
   },
   "devDependencies": {
diff --git a/examples/pg-proxy/src/server.ts b/examples/pg-proxy/src/server.ts
index 7c75f68eb..698b6c6ef 100644
--- a/examples/pg-proxy/src/server.ts
+++ b/examples/pg-proxy/src/server.ts
@@ -1,14 +1,25 @@
 import { Client } from 'pg';
 import express from 'express';
+import RateLimit from 'express-rate-limit';
 
 const app = express();
+
+const limiter = RateLimit({
+	windowMs: 15 * 60 * 1000, // 15 minutes
+	max: 100, // max 100 requests per windowMs
+});
+
 app.use(express.json());
+app.use(limiter);
 const port = 3000;
 
 const client = new Client('postgres://postgres:postgres@localhost:5432/postgres');
 
 app.post('/query', async (req, res) => {
-	const { sql: sqlBody, params, method } = req.body;
+	const { sql, params, method } = req.body;
+
+	// prevent multiple queries
+	const sqlBody = sql.replace(/;/g, '');
 
 	if (method === 'all') {
 		try {

From d38f3b42e47af5c86cf56b6497846e894b82fd9e Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Fri, 6 Oct 2023 00:10:01 -0400
Subject: [PATCH 36/72] [All] Resolved merge conflicts. Need to fix types

---
 .../mysql-core/query-builders/select.types.ts |  4 +-
 .../query-builders/set-operators.ts           | 78 ++++++++++------
 .../pg-core/query-builders/set-operators.ts   | 79 +++++++++++-----
 .../query-builders/select.types.ts            |  4 +-
 .../query-builders/set-operators.ts           | 93 +++++++++++++------
 5 files changed, 175 insertions(+), 83 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index 529ce0e5d..b8e295f32 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -239,12 +239,12 @@ export type CreateMySqlSelectFromBuilderMode<
 export type MySqlSelectQueryBuilder<
 	THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT,
 	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 	TResult = unknown,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+	TSelectedFields extends ColumnsSelection = Record<string, any>,
 > = MySqlSelectQueryBuilderBase<
 	THKT,
 	TTableName,
diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index ce76a3963..fb7916b47 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -74,7 +74,7 @@ export interface MySqlSetOperatorConfig {
 	fields: Record<string, unknown>;
 	operator: SetOperator;
 	isAll: boolean;
-	leftSelect: MySqlSetOperatorBuilder<any, any, any, any, any>;
+	leftSelect: MySqlSetOperatorBuilder<any, any, any, any, any, any, any, any, any>;
 	rightSelect: TypedQueryBuilder<any, any[]>;
 	limit?: number | Placeholder;
 	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
@@ -89,13 +89,13 @@ export interface MySqlSetOperatorBuilder<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends
-	TypedQueryBuilder<
-		BuildSubquerySelection<TSelection, TNullabilityMap>,
-		SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-	>,
-	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
-{}
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult> {}
 
 export abstract class MySqlSetOperatorBuilder<
 	TTableName extends string | undefined,
@@ -104,10 +104,11 @@ export abstract class MySqlSetOperatorBuilder<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-> {
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'MySqlSetOperatorBuilder';
 
 	protected abstract joinsNotNullableMap: Record<string, boolean>;
@@ -138,7 +139,17 @@ export abstract class MySqlSetOperatorBuilder<
 		rightSelect:
 			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
 			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	) => MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+	) => MySqlSetOperator<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	> {
 		return (rightSelect) => {
 			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
 			return new MySqlSetOperator(type, isAll, this, rightSelectOrig);
@@ -156,13 +167,6 @@ export abstract class MySqlSetOperatorBuilder<
 	except = this.setOperator('except', false);
 
 	exceptAll = this.setOperator('except', true);
-
-	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): this;
-	abstract orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): this;
-
-	abstract limit(limit: number): this;
-
-	abstract offset(offset: number | Placeholder): this;
 }
 
 export class MySqlSetOperator<
@@ -172,12 +176,20 @@ export class MySqlSetOperator<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends MySqlSetOperatorBuilder<
 	TTableName,
 	TSelection,
 	TSelectMode,
 	TPreparedQueryHKT,
-	TNullabilityMap
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
 > {
 	static readonly [entityKind]: string = 'MySqlSetOperator';
 
@@ -195,7 +207,11 @@ export class MySqlSetOperator<
 			TSelection,
 			TSelectMode,
 			TPreparedQueryHKT,
-			TNullabilityMap
+			TNullabilityMap,
+			TDynamic,
+			TExcludedMethods,
+			TResult,
+			TSelectedFields
 		>,
 		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
@@ -273,14 +289,14 @@ export class MySqlSetOperator<
 		}
 		const fieldsList = orderSelectedFields<MySqlColumn>(this.config.fields);
 		const query = this.session.prepareQuery<
-			PreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] },
+			PreparedQueryConfig & { execute: TResult },
 			TPreparedQueryHKT
 		>(this.dialect.sqlToQuery(this.getSQL()), fieldsList);
 		query.joinsNotNullableMap = this.joinsNotNullableMap;
 		return query as PreparedQueryKind<
 			TPreparedQueryHKT,
 			PreparedQueryConfig & {
-				execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+				execute: TResult;
 				iterator: SelectResult<TSelection, TSelectMode, TNullabilityMap>;
 			},
 			true
@@ -303,11 +319,11 @@ export class MySqlSetOperator<
 
 	as<TAlias extends string>(
 		alias: TAlias,
-	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias, 'mysql'> {
+	): SubqueryWithSelection<TSelectedFields, TAlias> {
 		return new Proxy(
 			new Subquery(this.getSQL(), this.config.fields, alias),
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias, 'mysql'>;
+		) as SubqueryWithSelection<TSelectedFields, TAlias>;
 	}
 }
 
@@ -322,7 +338,15 @@ function setOperator(type: SetOperator, isAll: boolean): <
 	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
 >(
-	leftSelect: MySqlSetOperatorBuilder<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap>,
+	leftSelect: MySqlSetOperatorBuilder<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap,
+		any,
+		any
+	>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
 ) => MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index c4ddccfa1..f40893c87 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -69,7 +69,7 @@ export interface PgSetOperationConfig {
 	fields: Record<string, unknown>;
 	operator: SetOperator;
 	isAll: boolean;
-	leftSelect: PgSetOperatorBuilder<any, any, any, any, any>;
+	leftSelect: PgSetOperatorBuilder<any, any, any, any, any, any, any, any, any>;
 	rightSelect: TypedQueryBuilder<any, any[]>;
 	limit?: number | Placeholder;
 	orderBy?: (PgColumn | SQL | SQL.Aliased)[];
@@ -84,10 +84,11 @@ export abstract class PgSetOperatorBuilder<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-> {
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'PgSetOperatorBuilder';
 
 	protected abstract joinsNotNullableMap: Record<string, boolean>;
@@ -118,7 +119,17 @@ export abstract class PgSetOperatorBuilder<
 		rightSelect:
 			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
 			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	) => PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+	) => PgSetOperator<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	> {
 		return (rightSelect) => {
 			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
 
@@ -137,13 +148,6 @@ export abstract class PgSetOperatorBuilder<
 	except = this.setOperator('except', false);
 
 	exceptAll = this.setOperator('except', true);
-
-	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
-	abstract orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
-
-	abstract limit(limit: number): this;
-
-	abstract offset(offset: number | Placeholder): this;
 }
 
 export interface PgSetOperator<
@@ -154,12 +158,23 @@ export interface PgSetOperator<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	TypedQueryBuilder<
-		BuildSubquerySelection<TSelection, TNullabilityMap>,
-		SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+	PgSetOperatorBuilder<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
 	>,
-	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
+	QueryPromise<TResult>
 {}
 
 export class PgSetOperator<
@@ -169,12 +184,20 @@ export class PgSetOperator<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends PgSetOperatorBuilder<
 	THKT,
 	TTableName,
 	TSelection,
 	TSelectMode,
-	TNullabilityMap
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
 > {
 	static readonly [entityKind]: string = 'PgSetOperator';
 
@@ -187,7 +210,17 @@ export class PgSetOperator<
 	constructor(
 		operator: SetOperator,
 		isAll: boolean,
-		leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
+		leftSelect: PgSetOperatorBuilder<
+			THKT,
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TNullabilityMap,
+			TDynamic,
+			TExcludedMethods,
+			TResult,
+			TSelectedFields
+		>,
 		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
 		super();
@@ -204,7 +237,7 @@ export class PgSetOperator<
 		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
 
 		this._ = {
-			selectedFields: fields as BuildSubquerySelection<TSelection, TNullabilityMap>,
+			selectedFields: fields as TSelectedFields,
 		} as this['_'];
 
 		this.session = session;
@@ -261,7 +294,7 @@ export class PgSetOperator<
 
 	private _prepare(name?: string): PreparedQuery<
 		PreparedQueryConfig & {
-			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+			execute: TResult;
 		}
 	> {
 		const { session, joinsNotNullableMap, config: { fields }, dialect } = this;
@@ -271,7 +304,7 @@ export class PgSetOperator<
 		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
 			const fieldsList = orderSelectedFields<PgColumn>(fields);
 			const query = session.prepareQuery<
-				PreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] }
+				PreparedQueryConfig & { execute: TResult }
 			>(dialect.sqlToQuery(this.getSQL()), fieldsList, name);
 			query.joinsNotNullableMap = joinsNotNullableMap;
 			return query;
@@ -287,7 +320,7 @@ export class PgSetOperator<
 	 */
 	prepare(name: string): PreparedQuery<
 		PreparedQueryConfig & {
-			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+			execute: TResult;
 		}
 	> {
 		return this._prepare(name);
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 62260b8e4..b7e7dd656 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -258,11 +258,11 @@ export type SQLiteSelectQueryBuilder<
 	TTableName extends string | undefined = string | undefined,
 	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
-	TSelection extends ColumnsSelection = ColumnsSelection,
+	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 	TResult = unknown,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+	TSelectedFields extends ColumnsSelection = Record<string, any>,
 > = SQLiteSelectQueryBuilderBase<
 	THKT,
 	TTableName,
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index 91e85bb36..2b81c9bf5 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -16,7 +16,7 @@ import type {
 	SelectResult,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { PreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
+import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { applyMixins, haveSameKeys, type PromiseOf, type ValidateShape } from '~/utils.ts';
 import type { ColumnsSelection } from '~/view.ts';
 import type { SQLiteColumn } from '../columns/common.ts';
@@ -66,7 +66,7 @@ export interface SQLiteSetOperationConfig {
 	fields: Record<string, unknown>;
 	operator: SetOperator;
 	isAll: boolean;
-	leftSelect: SQLiteSetOperatorBuilder<any, any, any, any, any, any, any>;
+	leftSelect: SQLiteSetOperatorBuilder<any, any, any, any, any, any, any, any, any, any>;
 	rightSelect: TypedQueryBuilder<any, any[]>;
 	limit?: number | Placeholder;
 	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
@@ -82,9 +82,13 @@ export abstract class SQLiteSetOperatorBuilder<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends TypedQueryBuilder<
-	BuildSubquerySelection<TSelection, TNullabilityMap>,
-	SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
+	TSelectedFields,
+	TResult
 > {
 	static readonly [entityKind]: string = 'SQLiteSetOperatorBuilder';
 
@@ -116,11 +120,35 @@ export abstract class SQLiteSetOperatorBuilder<
 		rightSelect:
 			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
 			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	) => SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+	) => SQLiteSetOperator<
+		THKT,
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	> {
 		return (rightSelect) => {
 			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
 
-			return new SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>(
+			return new SQLiteSetOperator<
+				THKT,
+				TTableName,
+				TResultType,
+				TRunResult,
+				TSelection,
+				TSelectMode,
+				TNullabilityMap,
+				TDynamic,
+				TExcludedMethods,
+				TResult,
+				TSelectedFields
+			>(
 				type,
 				isAll,
 				this,
@@ -136,13 +164,6 @@ export abstract class SQLiteSetOperatorBuilder<
 	intersect = this.setOperator('intersect', false);
 
 	except = this.setOperator('except', false);
-
-	abstract orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
-	abstract orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): this;
-
-	abstract limit(limit: number): this;
-
-	abstract offset(offset: number | Placeholder): this;
 }
 
 export interface SQLiteSetOperator<
@@ -157,13 +178,13 @@ export interface SQLiteSetOperator<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
-> extends
-	TypedQueryBuilder<
-		BuildSubquerySelection<TSelection, TNullabilityMap>,
-		SelectResult<TSelection, TSelectMode, TNullabilityMap>[]
-	>,
-	QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
-{}
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult> {}
 
 export class SQLiteSetOperator<
 	THKT extends SQLiteSelectHKTBase,
@@ -174,6 +195,10 @@ export class SQLiteSetOperator<
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends SQLiteSetOperatorBuilder<
 	THKT,
 	TTableName,
@@ -181,7 +206,11 @@ export class SQLiteSetOperator<
 	TRunResult,
 	TSelection,
 	TSelectMode,
-	TNullabilityMap
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
 > {
 	static readonly [entityKind]: string = 'SQLiteSetOperator';
 
@@ -201,7 +230,11 @@ export class SQLiteSetOperator<
 			TRunResult,
 			TSelection,
 			TSelectMode,
-			TNullabilityMap
+			TNullabilityMap,
+			TDynamic,
+			TExcludedMethods,
+			TResult,
+			TSelectedFields
 		>,
 		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
 	) {
@@ -219,7 +252,7 @@ export class SQLiteSetOperator<
 		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
 
 		this._ = {
-			selectedFields: fields as BuildSubquerySelection<TSelection, TNullabilityMap>,
+			selectedFields: fields as TSelectedFields,
 		} as this['_'];
 
 		this.session = session;
@@ -274,14 +307,14 @@ export class SQLiteSetOperator<
 		return this.dialect.buildSetOperationQuery(this.config);
 	}
 
-	prepare(isOneTimeQuery?: boolean): PreparedQuery<
+	prepare(isOneTimeQuery?: boolean): SQLitePreparedQuery<
 		{
 			type: TResultType;
 			run: TRunResult;
-			all: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+			all: TResult;
 			get: SelectResult<TSelection, TSelectMode, TNullabilityMap> | undefined;
 			values: any[][];
-			execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
+			execute: TResult;
 		}
 	> {
 		if (!this.session) {
@@ -313,7 +346,7 @@ export class SQLiteSetOperator<
 		return this.prepare(true).values(placeholderValues);
 	};
 
-	async execute(): Promise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
+	async execute(): Promise<TResult> {
 		return this.all() as PromiseOf<ReturnType<this['execute']>>;
 	}
 
@@ -347,11 +380,13 @@ function setOperator(type: SetOperator, isAll: boolean): <
 		TRunResult,
 		TSelection,
 		TSelectMode,
-		TNullabilityMap
+		TNullabilityMap,
+		any,
+		any
 	>,
 	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
 	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-) => SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+) => SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, any, any> {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		if (restSelects.length === 0) {
 			return new SQLiteSetOperator(type, isAll, leftSelect, rightSelect);

From 7ccbb55980ac4a52e10cc5713cbc962206761f9a Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Wed, 11 Oct 2023 16:30:42 +0300
Subject: [PATCH 37/72] Add d1 batch fixes

---
 drizzle-orm/src/d1/session.ts            | 57 ++++++++++++++++--------
 integration-tests/tests/d1-batch.test.ts |  2 -
 pnpm-lock.yaml                           |  2 +-
 3 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index 6adf3de73..aee75abf5 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -53,21 +53,6 @@ export class SQLiteD1Session<
 		return new D1PreparedQuery(stmt, query, this.logger, fields, executeMethod, customResultMapper);
 	}
 
-	/**
-	 * This function was taken from the D1 implementation: https://github.com/cloudflare/workerd/blob/4aae9f4c7ae30a59a88ca868c4aff88bda85c956/src/cloudflare/internal/d1-api.ts#L287
-	 * It may cause issues with duplicated column names in join queries, which should be fixed on the D1 side.
-	 * @param results
-	 * @returns
-	 */
-	private d1ToRawMapping(results: any) {
-		const rows: unknown[][] = [];
-		for (const row of results) {
-			const entry = Object.keys(row).map((k) => row[k]);
-			rows.push(entry);
-		}
-		return rows;
-	}
-
 	/*override */ async batch<U extends BatchItem, T extends Readonly<[U, ...U[]]>>(queries: T) {
 		const preparedQueries: PreparedQuery[] = [];
 		const builtQueries: D1PreparedStatement[] = [];
@@ -76,7 +61,14 @@ export class SQLiteD1Session<
 			const preparedQuery = query.prepare();
 			const builtQuery = preparedQuery.getQuery();
 			preparedQueries.push(preparedQuery);
-			builtQueries.push((preparedQuery as D1PreparedQuery).stmt.bind(...builtQuery.params));
+			if (builtQuery.params.length > 0) {
+				builtQueries.push((preparedQuery as D1PreparedQuery).stmt.bind(...builtQuery.params));
+			} else {
+				const builtQuery = preparedQuery.getQuery();
+				builtQueries.push(
+					this.client.prepare(builtQuery.sql).bind(...builtQuery.params),
+				);
+			}
 		}
 
 		// const queryToType: (
@@ -163,6 +155,18 @@ export class SQLiteD1Session<
 		// return res;
 	}
 
+	override extractRawAllValueFromBatchResult(_result: unknown): unknown {
+		return (_result as D1Result).results;
+	}
+
+	override extractRawGetValueFromBatchResult(result: unknown): unknown {
+		return (result as D1Result).results[0];
+	}
+
+	override extractRawValuesValueFromBatchResult(result: unknown): unknown {
+		return d1ToRawMapping((result as D1Result).results);
+	}
+
 	override async transaction<T>(
 		transaction: (tx: D1Transaction<TFullSchema, TSchema>) => T | Promise<T>,
 		config?: SQLiteTransactionConfig,
@@ -201,6 +205,21 @@ export class D1Transaction<
 	}
 }
 
+/**
+ * This function was taken from the D1 implementation: https://github.com/cloudflare/workerd/blob/4aae9f4c7ae30a59a88ca868c4aff88bda85c956/src/cloudflare/internal/d1-api.ts#L287
+ * It may cause issues with duplicated column names in join queries, which should be fixed on the D1 side.
+ * @param results
+ * @returns
+ */
+function d1ToRawMapping(results: any) {
+	const rows: unknown[][] = [];
+	for (const row of results) {
+		const entry = Object.keys(row).map((k) => row[k]);
+		rows.push(entry);
+	}
+	return rows;
+}
+
 export class D1PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig> extends SQLitePreparedQuery<
 	{ type: 'async'; run: D1Result; all: T['all']; get: T['get']; values: T['values']; execute: T['execute'] }
 > {
@@ -248,9 +267,9 @@ export class D1PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig
 		return this.mapAllResult(rows);
 	}
 
-	override mapAllResult(rows: unknown[], isFromBatch?: boolean): unknown {
+	override mapAllResult(rows: unknown, isFromBatch?: boolean): unknown {
 		if (isFromBatch) {
-			throw new Error('TODO');
+			rows = d1ToRawMapping((rows as D1Result).results);
 		}
 
 		if (!this.fields && !this.customResultMapper) {
@@ -287,7 +306,7 @@ export class D1PreparedQuery<T extends PreparedQueryConfig = PreparedQueryConfig
 
 	override mapGetResult(result: unknown, isFromBatch?: boolean): unknown {
 		if (isFromBatch) {
-			throw new Error('TODO');
+			result = d1ToRawMapping((result as D1Result).results)[0];
 		}
 
 		if (!this.fields && !this.customResultMapper) {
diff --git a/integration-tests/tests/d1-batch.test.ts b/integration-tests/tests/d1-batch.test.ts
index 0b323149d..7abebbb51 100644
--- a/integration-tests/tests/d1-batch.test.ts
+++ b/integration-tests/tests/d1-batch.test.ts
@@ -229,8 +229,6 @@ test('batch api example', async () => {
 		db.select().from(usersTable),
 	]);
 
-	console.log('batchResponse', batchResponse);
-
 	expectTypeOf(batchResponse).toEqualTypeOf<[
 		{
 			id: number;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6a490c92a..60584ac26 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,4 +1,4 @@
-lockfileVersion: '6.0'
+lockfileVersion: '6.1'
 
 settings:
   autoInstallPeers: true

From 2881b4ce15ea72865c9d3c7e87df37237b2b62e1 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Fri, 13 Oct 2023 01:16:23 +0300
Subject: [PATCH 38/72] Resolve circular dependencies

---
 drizzle-orm/src/alias.ts                      |   3 +-
 drizzle-orm/src/index.ts                      |   1 +
 drizzle-orm/src/mysql-core/dialect.ts         |   4 +-
 drizzle-orm/src/mysql-core/index.ts           |   1 +
 .../src/mysql-core/query-builders/query.ts    |  16 +-
 .../src/mysql-core/query-builders/select.ts   |   3 +-
 drizzle-orm/src/mysql-core/utils.ts           |   4 +-
 drizzle-orm/src/mysql-core/view-common.ts     |   1 +
 drizzle-orm/src/mysql-core/view.ts            |   3 +-
 drizzle-orm/src/pg-core/columns/array.ts      |   2 +-
 drizzle-orm/src/pg-core/dialect.ts            |   3 +-
 drizzle-orm/src/pg-core/index.ts              |   2 +
 .../src/pg-core/query-builders/select.ts      |   3 +-
 drizzle-orm/src/pg-core/utils.ts              | 101 +--
 drizzle-orm/src/pg-core/utils/array.ts        |  95 +++
 drizzle-orm/src/pg-core/utils/index.ts        |   1 +
 drizzle-orm/src/pg-core/view-common.ts        |   1 +
 drizzle-orm/src/pg-core/view.ts               |   3 +-
 drizzle-orm/src/sql/expressions/conditions.ts |   2 +-
 drizzle-orm/src/sql/expressions/select.ts     |   4 +-
 drizzle-orm/src/sql/index.ts                  | 585 +-----------------
 drizzle-orm/src/sql/sql.ts                    | 584 +++++++++++++++++
 drizzle-orm/src/sqlite-core/dialect.ts        |   2 +-
 .../src/sqlite-core/query-builders/select.ts  |   3 +-
 .../src/sqlite-core/unique-constraint.ts      |   2 +-
 drizzle-orm/src/sqlite-core/utils.ts          |   5 +-
 drizzle-orm/src/sqlite-core/view-common.ts    |   1 +
 drizzle-orm/src/sqlite-core/view.ts           |   5 +-
 drizzle-orm/src/sqlite-proxy/session.ts       |   4 +-
 drizzle-orm/src/subquery.ts                   |   3 +-
 drizzle-orm/src/table.ts                      |   4 +-
 drizzle-orm/src/utils.ts                      |   3 +-
 drizzle-orm/src/view-common.ts                |   1 +
 drizzle-orm/src/view.ts                       |   3 +-
 drizzle-typebox/tests/utils.ts                |   3 +-
 drizzle-valibot/tests/utils.ts                |   3 +-
 drizzle-zod/tests/utils.ts                    |   2 +-
 37 files changed, 736 insertions(+), 730 deletions(-)
 create mode 100644 drizzle-orm/src/mysql-core/view-common.ts
 create mode 100644 drizzle-orm/src/pg-core/utils/array.ts
 create mode 100644 drizzle-orm/src/pg-core/utils/index.ts
 create mode 100644 drizzle-orm/src/pg-core/view-common.ts
 create mode 100644 drizzle-orm/src/sql/sql.ts
 create mode 100644 drizzle-orm/src/sqlite-core/view-common.ts
 create mode 100644 drizzle-orm/src/view-common.ts

diff --git a/drizzle-orm/src/alias.ts b/drizzle-orm/src/alias.ts
index e570921d2..06269921e 100644
--- a/drizzle-orm/src/alias.ts
+++ b/drizzle-orm/src/alias.ts
@@ -4,7 +4,8 @@ import { entityKind, is } from './entity.ts';
 import type { Relation } from './relations.ts';
 import { SQL, sql } from './sql/index.ts';
 import { Table } from './table.ts';
-import { type View, ViewBaseConfig } from './view.ts';
+import { ViewBaseConfig } from './view-common.ts';
+import type { View } from './view.ts';
 
 export class ColumnAliasProxyHandler<TColumn extends Column> implements ProxyHandler<TColumn> {
 	static readonly [entityKind]: string = 'ColumnAliasProxyHandler';
diff --git a/drizzle-orm/src/index.ts b/drizzle-orm/src/index.ts
index 2eb9a58ca..66b45c585 100644
--- a/drizzle-orm/src/index.ts
+++ b/drizzle-orm/src/index.ts
@@ -12,4 +12,5 @@ export * from './sql/index.ts';
 export * from './subquery.ts';
 export * from './table.ts';
 export * from './utils.ts';
+export * from './view-common.ts';
 export * from './view.ts';
diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index 28b61e123..03c567069 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -18,8 +18,8 @@ import { and, eq, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
-import { View, ViewBaseConfig } from '~/view.ts';
-import { DrizzleError } from '../index.ts';
+import { View } from '~/view.ts';
+import { DrizzleError, ViewBaseConfig } from '../index.ts';
 import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
diff --git a/drizzle-orm/src/mysql-core/index.ts b/drizzle-orm/src/mysql-core/index.ts
index 7120e0c5c..204e0af3c 100644
--- a/drizzle-orm/src/mysql-core/index.ts
+++ b/drizzle-orm/src/mysql-core/index.ts
@@ -13,4 +13,5 @@ export * from './subquery.ts';
 export * from './table.ts';
 export * from './unique-constraint.ts';
 export * from './utils.ts';
+export * from './view-common.ts';
 export * from './view.ts';
diff --git a/drizzle-orm/src/mysql-core/query-builders/query.ts b/drizzle-orm/src/mysql-core/query-builders/query.ts
index c1433c963..3b28b1888 100644
--- a/drizzle-orm/src/mysql-core/query-builders/query.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/query.ts
@@ -8,17 +8,11 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type Query, type QueryWithTypings, type SQL } from '~/sql/index.ts';
-import { type KnownKeysOnly } from '~/utils.ts';
-import { type MySqlDialect } from '../dialect.ts';
-import {
-	type Mode,
-	type MySqlSession,
-	type PreparedQueryConfig,
-	type PreparedQueryHKTBase,
-	type PreparedQueryKind,
-} from '../session.ts';
-import { type MySqlTable } from '../table.ts';
+import type { Query, QueryWithTypings, SQL } from '~/sql/index.ts';
+import type { KnownKeysOnly } from '~/utils.ts';
+import type { MySqlDialect } from '../dialect.ts';
+import type { Mode, MySqlSession, PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
+import type { MySqlTable } from '../table.ts';
 
 export class RelationalQueryBuilder<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.ts b/drizzle-orm/src/mysql-core/query-builders/select.ts
index bc65edd91..4dd4f5cda 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.ts
@@ -21,7 +21,8 @@ import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
 import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } from '~/utils.ts';
 import { orderSelectedFields } from '~/utils.ts';
-import { type ColumnsSelection, View, ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import { type ColumnsSelection, View } from '~/view.ts';
 import type {
 	CreateMySqlSelectFromBuilderMode,
 	LockConfig,
diff --git a/drizzle-orm/src/mysql-core/utils.ts b/drizzle-orm/src/mysql-core/utils.ts
index 1d53694f7..f09f65f3e 100644
--- a/drizzle-orm/src/mysql-core/utils.ts
+++ b/drizzle-orm/src/mysql-core/utils.ts
@@ -1,6 +1,6 @@
 import { is } from '~/entity.ts';
 import { Table } from '~/table.ts';
-import { ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
 import type { Check } from './checks.ts';
 import { CheckBuilder } from './checks.ts';
 import type { ForeignKey } from './foreign-keys.ts';
@@ -11,8 +11,8 @@ import type { PrimaryKey } from './primary-keys.ts';
 import { PrimaryKeyBuilder } from './primary-keys.ts';
 import { MySqlTable } from './table.ts';
 import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
+import { MySqlViewConfig } from './view-common.ts';
 import type { MySqlView } from './view.ts';
-import { MySqlViewConfig } from './view.ts';
 
 export function getTableConfig(table: MySqlTable) {
 	const columns = Object.values(table[MySqlTable.Symbol.Columns]);
diff --git a/drizzle-orm/src/mysql-core/view-common.ts b/drizzle-orm/src/mysql-core/view-common.ts
new file mode 100644
index 000000000..9bbc130c3
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/view-common.ts
@@ -0,0 +1 @@
+export const MySqlViewConfig = Symbol.for('drizzle:MySqlViewConfig');
diff --git a/drizzle-orm/src/mysql-core/view.ts b/drizzle-orm/src/mysql-core/view.ts
index 5c81dff21..4d0dd216f 100644
--- a/drizzle-orm/src/mysql-core/view.ts
+++ b/drizzle-orm/src/mysql-core/view.ts
@@ -10,6 +10,7 @@ import { type MySqlColumn, type MySqlColumnBuilderBase } from './columns/index.t
 import { QueryBuilder } from './query-builders/index.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { mysqlTable } from './table.ts';
+import { MySqlViewConfig } from './view-common.ts';
 
 export interface ViewBuilderConfig {
 	algorithm?: 'undefined' | 'merge' | 'temptable';
@@ -163,8 +164,6 @@ export abstract class MySqlViewBase<
 	};
 }
 
-export const MySqlViewConfig = Symbol.for('drizzle:MySqlViewConfig');
-
 export class MySqlView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
diff --git a/drizzle-orm/src/pg-core/columns/array.ts b/drizzle-orm/src/pg-core/columns/array.ts
index 4106f18d5..cef68999e 100644
--- a/drizzle-orm/src/pg-core/columns/array.ts
+++ b/drizzle-orm/src/pg-core/columns/array.ts
@@ -7,7 +7,7 @@ import type {
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import { makePgArray, parsePgArray } from '../utils.ts';
+import { makePgArray, parsePgArray } from '../utils/array.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 export class PgArrayBuilder<
diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 671ff8e55..8f274d493 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -37,7 +37,8 @@ import {
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
-import { View, ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import { View } from '~/view.ts';
 import type { PgSession } from './session.ts';
 import { type PgMaterializedView, PgViewBase } from './view.ts';
 
diff --git a/drizzle-orm/src/pg-core/index.ts b/drizzle-orm/src/pg-core/index.ts
index 7120e0c5c..1a80ff7ad 100644
--- a/drizzle-orm/src/pg-core/index.ts
+++ b/drizzle-orm/src/pg-core/index.ts
@@ -13,4 +13,6 @@ export * from './subquery.ts';
 export * from './table.ts';
 export * from './unique-constraint.ts';
 export * from './utils.ts';
+export * from './utils/index.ts';
+export * from './view-common.ts';
 export * from './view.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index a18664906..f954f3340 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -22,7 +22,8 @@ import { Table } from '~/table.ts';
 import { tracer } from '~/tracing.ts';
 import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } from '~/utils.ts';
 import { orderSelectedFields } from '~/utils.ts';
-import { type ColumnsSelection, View, ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import { type ColumnsSelection, View } from '~/view.ts';
 import type {
 	CreatePgSelectFromBuilderMode,
 	LockConfig,
diff --git a/drizzle-orm/src/pg-core/utils.ts b/drizzle-orm/src/pg-core/utils.ts
index 87a72bb0e..325b7191a 100644
--- a/drizzle-orm/src/pg-core/utils.ts
+++ b/drizzle-orm/src/pg-core/utils.ts
@@ -1,14 +1,15 @@
 import { is } from '~/entity.ts';
 import { PgTable } from '~/pg-core/table.ts';
 import { Table } from '~/table.ts';
-import { ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
 import { type Check, CheckBuilder } from './checks.ts';
 import type { AnyPgColumn } from './columns/index.ts';
 import { type ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
 import { type Index, IndexBuilder } from './indexes.ts';
 import { type PrimaryKey, PrimaryKeyBuilder } from './primary-keys.ts';
 import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
-import { type PgMaterializedView, PgMaterializedViewConfig, type PgView, PgViewConfig } from './view.ts';
+import { PgViewConfig } from './view-common.ts';
+import { type PgMaterializedView, PgMaterializedViewConfig, type PgView } from './view.ts';
 
 export function getTableConfig<TTable extends PgTable>(table: TTable) {
 	const columns = Object.values(table[Table.Symbol.Columns]);
@@ -71,102 +72,6 @@ export function getMaterializedViewConfig<
 	};
 }
 
-function parsePgArrayValue(arrayString: string, startFrom: number, inQuotes: boolean): [string, number] {
-	for (let i = startFrom; i < arrayString.length; i++) {
-		const char = arrayString[i];
-
-		if (char === '\\') {
-			i++;
-			continue;
-		}
-
-		if (char === '"') {
-			return [arrayString.slice(startFrom, i).replace(/\\/g, ''), i + 1];
-		}
-
-		if (inQuotes) {
-			continue;
-		}
-
-		if (char === ',' || char === '}') {
-			return [arrayString.slice(startFrom, i).replace(/\\/g, ''), i];
-		}
-	}
-
-	return [arrayString.slice(startFrom).replace(/\\/g, ''), arrayString.length];
-}
-
-export function parsePgNestedArray(arrayString: string, startFrom = 0): [any[], number] {
-	const result: any[] = [];
-	let i = startFrom;
-	let lastCharIsComma = false;
-
-	while (i < arrayString.length) {
-		const char = arrayString[i];
-
-		if (char === ',') {
-			if (lastCharIsComma || i === startFrom) {
-				result.push('');
-			}
-			lastCharIsComma = true;
-			i++;
-			continue;
-		}
-
-		lastCharIsComma = false;
-
-		if (char === '\\') {
-			i += 2;
-			continue;
-		}
-
-		if (char === '"') {
-			const [value, startFrom] = parsePgArrayValue(arrayString, i + 1, true);
-			result.push(value);
-			i = startFrom;
-			continue;
-		}
-
-		if (char === '}') {
-			return [result, i + 1];
-		}
-
-		if (char === '{') {
-			const [value, startFrom] = parsePgNestedArray(arrayString, i + 1);
-			result.push(value);
-			i = startFrom;
-			continue;
-		}
-
-		const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
-		result.push(value);
-		i = newStartFrom;
-	}
-
-	return [result, i];
-}
-
-export function parsePgArray(arrayString: string): any[] {
-	const [result] = parsePgNestedArray(arrayString, 1);
-	return result;
-}
-
-export function makePgArray(array: any[]): string {
-	return `{${
-		array.map((item) => {
-			if (Array.isArray(item)) {
-				return makePgArray(item);
-			}
-
-			if (typeof item === 'string' && item.includes(',')) {
-				return `"${item.replace(/"/g, '\\"')}"`;
-			}
-
-			return `${item}`;
-		}).join(',')
-	}}`;
-}
-
 export type ColumnsWithTable<
 	TTableName extends string,
 	TForeignTableName extends string,
diff --git a/drizzle-orm/src/pg-core/utils/array.ts b/drizzle-orm/src/pg-core/utils/array.ts
new file mode 100644
index 000000000..fef4d3fb2
--- /dev/null
+++ b/drizzle-orm/src/pg-core/utils/array.ts
@@ -0,0 +1,95 @@
+function parsePgArrayValue(arrayString: string, startFrom: number, inQuotes: boolean): [string, number] {
+	for (let i = startFrom; i < arrayString.length; i++) {
+		const char = arrayString[i];
+
+		if (char === '\\') {
+			i++;
+			continue;
+		}
+
+		if (char === '"') {
+			return [arrayString.slice(startFrom, i).replace(/\\/g, ''), i + 1];
+		}
+
+		if (inQuotes) {
+			continue;
+		}
+
+		if (char === ',' || char === '}') {
+			return [arrayString.slice(startFrom, i).replace(/\\/g, ''), i];
+		}
+	}
+
+	return [arrayString.slice(startFrom).replace(/\\/g, ''), arrayString.length];
+}
+
+export function parsePgNestedArray(arrayString: string, startFrom = 0): [any[], number] {
+	const result: any[] = [];
+	let i = startFrom;
+	let lastCharIsComma = false;
+
+	while (i < arrayString.length) {
+		const char = arrayString[i];
+
+		if (char === ',') {
+			if (lastCharIsComma || i === startFrom) {
+				result.push('');
+			}
+			lastCharIsComma = true;
+			i++;
+			continue;
+		}
+
+		lastCharIsComma = false;
+
+		if (char === '\\') {
+			i += 2;
+			continue;
+		}
+
+		if (char === '"') {
+			const [value, startFrom] = parsePgArrayValue(arrayString, i + 1, true);
+			result.push(value);
+			i = startFrom;
+			continue;
+		}
+
+		if (char === '}') {
+			return [result, i + 1];
+		}
+
+		if (char === '{') {
+			const [value, startFrom] = parsePgNestedArray(arrayString, i + 1);
+			result.push(value);
+			i = startFrom;
+			continue;
+		}
+
+		const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+		result.push(value);
+		i = newStartFrom;
+	}
+
+	return [result, i];
+}
+
+export function parsePgArray(arrayString: string): any[] {
+	const [result] = parsePgNestedArray(arrayString, 1);
+	return result;
+}
+
+export function makePgArray(array: any[]): string {
+	return `{${
+		array.map((item) => {
+			if (Array.isArray(item)) {
+				return makePgArray(item);
+			}
+
+			if (typeof item === 'string' && item.includes(',')) {
+				return `"${item.replace(/"/g, '\\"')}"`;
+			}
+
+			return `${item}`;
+		}).join(',')
+	}}`;
+}
diff --git a/drizzle-orm/src/pg-core/utils/index.ts b/drizzle-orm/src/pg-core/utils/index.ts
new file mode 100644
index 000000000..76eb91d0b
--- /dev/null
+++ b/drizzle-orm/src/pg-core/utils/index.ts
@@ -0,0 +1 @@
+export * from './array.ts';
diff --git a/drizzle-orm/src/pg-core/view-common.ts b/drizzle-orm/src/pg-core/view-common.ts
new file mode 100644
index 000000000..01194c7f2
--- /dev/null
+++ b/drizzle-orm/src/pg-core/view-common.ts
@@ -0,0 +1 @@
+export const PgViewConfig = Symbol.for('drizzle:PgViewConfig');
diff --git a/drizzle-orm/src/pg-core/view.ts b/drizzle-orm/src/pg-core/view.ts
index 0ddfcf772..4e4eed3ce 100644
--- a/drizzle-orm/src/pg-core/view.ts
+++ b/drizzle-orm/src/pg-core/view.ts
@@ -10,6 +10,7 @@ import type { PgColumn, PgColumnBuilderBase } from './columns/common.ts';
 import { QueryBuilder } from './query-builders/index.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { pgTable } from './table.ts';
+import { PgViewConfig } from './view-common.ts';
 
 export interface ViewWithConfig {
 	checkOption: 'local' | 'cascaded';
@@ -282,8 +283,6 @@ export abstract class PgViewBase<
 	};
 }
 
-export const PgViewConfig = Symbol.for('drizzle:PgViewConfig');
-
 export class PgView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
diff --git a/drizzle-orm/src/sql/expressions/conditions.ts b/drizzle-orm/src/sql/expressions/conditions.ts
index c84383703..774760366 100644
--- a/drizzle-orm/src/sql/expressions/conditions.ts
+++ b/drizzle-orm/src/sql/expressions/conditions.ts
@@ -12,7 +12,7 @@ import {
 	type SQLChunk,
 	type SQLWrapper,
 	StringChunk,
-} from '../index.ts';
+} from '../sql.ts';
 
 export function bindIfParam(value: unknown, column: SQLWrapper): SQLChunk {
 	if (
diff --git a/drizzle-orm/src/sql/expressions/select.ts b/drizzle-orm/src/sql/expressions/select.ts
index 4308454cd..2ff8de346 100644
--- a/drizzle-orm/src/sql/expressions/select.ts
+++ b/drizzle-orm/src/sql/expressions/select.ts
@@ -1,6 +1,6 @@
 import type { AnyColumn } from '../../column.ts';
-import type { SQL, SQLWrapper } from '../index.ts';
-import { sql } from '../index.ts';
+import type { SQL, SQLWrapper } from '../sql.ts';
+import { sql } from '../sql.ts';
 
 /**
  * Used in sorting, this specifies that the given
diff --git a/drizzle-orm/src/sql/index.ts b/drizzle-orm/src/sql/index.ts
index 9a611c861..ec7f9ed76 100644
--- a/drizzle-orm/src/sql/index.ts
+++ b/drizzle-orm/src/sql/index.ts
@@ -1,585 +1,2 @@
-import { entityKind, is } from '~/entity.ts';
-import { Relation } from '~/relations.ts';
-import { Subquery, SubqueryConfig } from '~/subquery.ts';
-import { tracer } from '~/tracing.ts';
-import { View, ViewBaseConfig } from '~/view.ts';
-import type { AnyColumn } from '../column.ts';
-import { Column } from '../column.ts';
-import { Table } from '../table.ts';
-
 export * from './expressions/index.ts';
-
-/**
- * This class is used to indicate a primitive param value that is used in `sql` tag.
- * It is only used on type level and is never instantiated at runtime.
- * If you see a value of this type in the code, its runtime value is actually the primitive param value.
- */
-export class FakePrimitiveParam {
-	static readonly [entityKind]: string = 'FakePrimitiveParam';
-}
-
-export type Chunk =
-	| string
-	| Table
-	| View
-	| AnyColumn
-	| Name
-	| Param
-	| Placeholder
-	| SQL;
-
-export interface BuildQueryConfig {
-	escapeName(name: string): string;
-	escapeParam(num: number, value: unknown): string;
-	escapeString(str: string): string;
-	prepareTyping?: (encoder: DriverValueEncoder<unknown, unknown>) => QueryTypingsValue;
-	paramStartIndex?: { value: number };
-	inlineParams?: boolean;
-}
-
-export type QueryTypingsValue = 'json' | 'decimal' | 'time' | 'timestamp' | 'uuid' | 'date' | 'none';
-
-export interface Query {
-	sql: string;
-	params: unknown[];
-}
-
-export interface QueryWithTypings extends Query {
-	typings?: QueryTypingsValue[];
-}
-
-/**
- * Any value that implements the `getSQL` method. The implementations include:
- * - `Table`
- * - `Column`
- * - `View`
- * - `Subquery`
- * - `SQL`
- * - `SQL.Aliased`
- * - `Placeholder`
- * - `Param`
- */
-export interface SQLWrapper {
-	getSQL(): SQL;
-}
-
-export function isSQLWrapper(value: unknown): value is SQLWrapper {
-	return typeof value === 'object' && value !== null && 'getSQL' in value
-		&& typeof (value as any).getSQL === 'function';
-}
-
-function mergeQueries(queries: QueryWithTypings[]): QueryWithTypings {
-	const result: QueryWithTypings = { sql: '', params: [] };
-	for (const query of queries) {
-		result.sql += query.sql;
-		result.params.push(...query.params);
-		if (query.typings?.length) {
-			if (!result.typings) {
-				result.typings = [];
-			}
-			result.typings.push(...query.typings);
-		}
-	}
-	return result;
-}
-
-export class StringChunk implements SQLWrapper {
-	static readonly [entityKind]: string = 'StringChunk';
-
-	readonly value: string[];
-
-	constructor(value: string | string[]) {
-		this.value = Array.isArray(value) ? value : [value];
-	}
-
-	getSQL(): SQL<unknown> {
-		return new SQL([this]);
-	}
-}
-
-export class SQL<T = unknown> implements SQLWrapper {
-	static readonly [entityKind]: string = 'SQL';
-
-	declare _: {
-		brand: 'SQL';
-		type: T;
-	};
-
-	/** @internal */
-	decoder: DriverValueDecoder<T, any> = noopDecoder;
-	private shouldInlineParams = false;
-
-	constructor(readonly queryChunks: SQLChunk[]) {}
-
-	append(query: SQL): this {
-		this.queryChunks.push(...query.queryChunks);
-		return this;
-	}
-
-	toQuery(config: BuildQueryConfig): QueryWithTypings {
-		return tracer.startActiveSpan('drizzle.buildSQL', (span) => {
-			const query = this.buildQueryFromSourceParams(this.queryChunks, config);
-			span?.setAttributes({
-				'drizzle.query.text': query.sql,
-				'drizzle.query.params': JSON.stringify(query.params),
-			});
-			return query;
-		});
-	}
-
-	buildQueryFromSourceParams(chunks: SQLChunk[], _config: BuildQueryConfig): Query {
-		const config = Object.assign({}, _config, {
-			inlineParams: _config.inlineParams || this.shouldInlineParams,
-			paramStartIndex: _config.paramStartIndex || { value: 0 },
-		});
-
-		const {
-			escapeName,
-			escapeParam,
-			prepareTyping,
-			inlineParams,
-			paramStartIndex,
-		} = config;
-
-		return mergeQueries(chunks.map((chunk): QueryWithTypings => {
-			if (is(chunk, StringChunk)) {
-				return { sql: chunk.value.join(''), params: [] };
-			}
-
-			if (is(chunk, Name)) {
-				return { sql: escapeName(chunk.value), params: [] };
-			}
-
-			if (chunk === undefined) {
-				return { sql: '', params: [] };
-			}
-
-			if (Array.isArray(chunk)) {
-				const result: SQLChunk[] = [new StringChunk('(')];
-				for (const [i, p] of chunk.entries()) {
-					result.push(p);
-					if (i < chunk.length - 1) {
-						result.push(new StringChunk(', '));
-					}
-				}
-				result.push(new StringChunk(')'));
-				return this.buildQueryFromSourceParams(result, config);
-			}
-
-			if (is(chunk, SQL)) {
-				return this.buildQueryFromSourceParams(chunk.queryChunks, {
-					...config,
-					inlineParams: inlineParams || chunk.shouldInlineParams,
-				});
-			}
-
-			if (is(chunk, Table)) {
-				const schemaName = chunk[Table.Symbol.Schema];
-				const tableName = chunk[Table.Symbol.Name];
-				return {
-					sql: schemaName === undefined
-						? escapeName(tableName)
-						: escapeName(schemaName) + '.' + escapeName(tableName),
-					params: [],
-				};
-			}
-
-			if (is(chunk, Column)) {
-				return { sql: escapeName(chunk.table[Table.Symbol.Name]) + '.' + escapeName(chunk.name), params: [] };
-			}
-
-			if (is(chunk, View)) {
-				const schemaName = chunk[ViewBaseConfig].schema;
-				const viewName = chunk[ViewBaseConfig].name;
-				return {
-					sql: schemaName === undefined
-						? escapeName(viewName)
-						: escapeName(schemaName) + '.' + escapeName(viewName),
-					params: [],
-				};
-			}
-
-			if (is(chunk, Param)) {
-				const mappedValue = (chunk.value === null) ? null : chunk.encoder.mapToDriverValue(chunk.value);
-
-				if (is(mappedValue, SQL)) {
-					return this.buildQueryFromSourceParams([mappedValue], config);
-				}
-
-				if (inlineParams) {
-					return { sql: this.mapInlineParam(mappedValue, config), params: [] };
-				}
-
-				let typings: QueryTypingsValue[] | undefined;
-				if (prepareTyping !== undefined) {
-					typings = [prepareTyping(chunk.encoder)];
-				}
-
-				return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
-			}
-
-			if (is(chunk, Placeholder)) {
-				return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
-			}
-
-			if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
-				return { sql: escapeName(chunk.fieldAlias), params: [] };
-			}
-
-			if (is(chunk, Subquery)) {
-				if (chunk[SubqueryConfig].isWith) {
-					return { sql: escapeName(chunk[SubqueryConfig].alias), params: [] };
-				}
-				return this.buildQueryFromSourceParams([
-					new StringChunk('('),
-					chunk[SubqueryConfig].sql,
-					new StringChunk(') '),
-					new Name(chunk[SubqueryConfig].alias),
-				], config);
-			}
-
-			// if (is(chunk, Placeholder)) {
-			// 	return {sql: escapeParam}
-
-			if (isSQLWrapper(chunk)) {
-				return this.buildQueryFromSourceParams([
-					new StringChunk('('),
-					chunk.getSQL(),
-					new StringChunk(')'),
-				], config);
-			}
-
-			if (is(chunk, Relation)) {
-				return this.buildQueryFromSourceParams([
-					chunk.sourceTable,
-					new StringChunk('.'),
-					sql.identifier(chunk.fieldName),
-				], config);
-			}
-
-			if (inlineParams) {
-				return { sql: this.mapInlineParam(chunk, config), params: [] };
-			}
-
-			return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
-		}));
-	}
-
-	private mapInlineParam(
-		chunk: unknown,
-		{ escapeString }: BuildQueryConfig,
-	): string {
-		if (chunk === null) {
-			return 'null';
-		}
-		if (typeof chunk === 'number' || typeof chunk === 'boolean') {
-			return chunk.toString();
-		}
-		if (typeof chunk === 'string') {
-			return escapeString(chunk);
-		}
-		if (typeof chunk === 'object') {
-			const mappedValueAsString = chunk.toString();
-			if (mappedValueAsString === '[object Object]') {
-				return escapeString(JSON.stringify(chunk));
-			}
-			return escapeString(mappedValueAsString);
-		}
-		throw new Error('Unexpected param value: ' + chunk);
-	}
-
-	getSQL(): SQL {
-		return this;
-	}
-
-	as(alias: string): SQL.Aliased<T>;
-	/**
-	 * @deprecated
-	 * Use ``sql<DataType>`query`.as(alias)`` instead.
-	 */
-	as<TData>(): SQL<TData>;
-	/**
-	 * @deprecated
-	 * Use ``sql<DataType>`query`.as(alias)`` instead.
-	 */
-	as<TData>(alias: string): SQL.Aliased<TData>;
-	as(alias?: string): SQL<T> | SQL.Aliased<T> {
-		// TODO: remove with deprecated overloads
-		if (alias === undefined) {
-			return this;
-		}
-
-		return new SQL.Aliased(this, alias);
-	}
-
-	mapWith<
-		TDecoder extends
-			| DriverValueDecoder<any, any>
-			| DriverValueDecoder<any, any>['mapFromDriverValue'],
-	>(decoder: TDecoder): SQL<GetDecoderResult<TDecoder>> {
-		this.decoder = typeof decoder === 'function' ? { mapFromDriverValue: decoder } : decoder;
-		return this as SQL<GetDecoderResult<TDecoder>>;
-	}
-
-	inlineParams(): this {
-		this.shouldInlineParams = true;
-		return this;
-	}
-}
-
-export type GetDecoderResult<T> = T extends Column ? T['_']['data'] : T extends
-	| DriverValueDecoder<infer TData, any>
-	| DriverValueDecoder<infer TData, any>['mapFromDriverValue'] ? TData
-: never;
-
-/**
- * Any DB name (table, column, index etc.)
- */
-export class Name implements SQLWrapper {
-	static readonly [entityKind]: string = 'Name';
-
-	protected brand!: 'Name';
-
-	constructor(readonly value: string) {}
-
-	getSQL(): SQL<unknown> {
-		return new SQL([this]);
-	}
-}
-
-/**
- * Any DB name (table, column, index etc.)
- * @deprecated Use `sql.identifier` instead.
- */
-export function name(value: string): Name {
-	return new Name(value);
-}
-
-export interface DriverValueDecoder<TData, TDriverParam> {
-	mapFromDriverValue(value: TDriverParam): TData;
-}
-
-export interface DriverValueEncoder<TData, TDriverParam> {
-	mapToDriverValue(value: TData): TDriverParam | SQL;
-}
-
-export function isDriverValueEncoder(value: unknown): value is DriverValueEncoder<any, any> {
-	return typeof value === 'object' && value !== null && 'mapToDriverValue' in value
-		&& typeof (value as any).mapToDriverValue === 'function';
-}
-
-export const noopDecoder: DriverValueDecoder<any, any> = {
-	mapFromDriverValue: (value) => value,
-};
-
-export const noopEncoder: DriverValueEncoder<any, any> = {
-	mapToDriverValue: (value) => value,
-};
-
-export interface DriverValueMapper<TData, TDriverParam>
-	extends DriverValueDecoder<TData, TDriverParam>, DriverValueEncoder<TData, TDriverParam>
-{}
-
-export const noopMapper: DriverValueMapper<any, any> = {
-	...noopDecoder,
-	...noopEncoder,
-};
-
-/** Parameter value that is optionally bound to an encoder (for example, a column). */
-export class Param<TDataType = unknown, TDriverParamType = TDataType> implements SQLWrapper {
-	static readonly [entityKind]: string = 'Param';
-
-	protected brand!: 'BoundParamValue';
-
-	/**
-	 * @param value - Parameter value
-	 * @param encoder - Encoder to convert the value to a driver parameter
-	 */
-	constructor(
-		readonly value: TDataType,
-		readonly encoder: DriverValueEncoder<TDataType, TDriverParamType> = noopEncoder,
-	) {}
-
-	getSQL(): SQL<unknown> {
-		return new SQL([this]);
-	}
-}
-
-/** @deprecated Use `sql.param` instead. */
-export function param<TData, TDriver>(
-	value: TData,
-	encoder?: DriverValueEncoder<TData, TDriver>,
-): Param<TData, TDriver> {
-	return new Param(value, encoder);
-}
-
-/**
- * Anything that can be passed to the `` sql`...` `` tagged function.
- */
-export type SQLChunk =
-	| StringChunk
-	| SQLChunk[]
-	| SQLWrapper
-	| SQL
-	| Table
-	| View
-	| Subquery
-	| AnyColumn
-	| Param
-	| Name
-	| undefined
-	| FakePrimitiveParam
-	| Placeholder;
-
-export function sql<T>(strings: TemplateStringsArray, ...params: any[]): SQL<T>;
-/*
-	The type of `params` is specified as `SQLSourceParam[]`, but that's slightly incorrect -
-	in runtime, users won't pass `FakePrimitiveParam` instances as `params` - they will pass primitive values
-	which will be wrapped in `Param` using `buildChunksFromParam(...)`. That's why the overload
-	specify `params` as `any[]` and not as `SQLSourceParam[]`. This type is used to make our lives easier and
-	the type checker happy.
-*/
-export function sql(strings: TemplateStringsArray, ...params: SQLChunk[]): SQL {
-	const queryChunks: SQLChunk[] = [];
-	if (params.length > 0 || (strings.length > 0 && strings[0] !== '')) {
-		queryChunks.push(new StringChunk(strings[0]!));
-	}
-	for (const [paramIndex, param] of params.entries()) {
-		queryChunks.push(param, new StringChunk(strings[paramIndex + 1]!));
-	}
-
-	return new SQL(queryChunks);
-}
-
-export namespace sql {
-	export function empty(): SQL {
-		return new SQL([]);
-	}
-
-	/** @deprecated - use `sql.join()` */
-	export function fromList(list: SQLChunk[]): SQL {
-		return new SQL(list);
-	}
-
-	/**
-	 * Convenience function to create an SQL query from a raw string.
-	 * @param str The raw SQL query string.
-	 */
-	export function raw(str: string): SQL {
-		return new SQL([new StringChunk(str)]);
-	}
-
-	/**
-	 * Join a list of SQL chunks with a separator.
-	 * @example
-	 * ```ts
-	 * const query = sql.join([sql`a`, sql`b`, sql`c`]);
-	 * // sql`abc`
-	 * ```
-	 * @example
-	 * ```ts
-	 * const query = sql.join([sql`a`, sql`b`, sql`c`], sql`, `);
-	 * // sql`a, b, c`
-	 * ```
-	 */
-	export function join(chunks: SQLChunk[], separator?: SQLChunk): SQL {
-		const result: SQLChunk[] = [];
-		for (const [i, chunk] of chunks.entries()) {
-			if (i > 0 && separator !== undefined) {
-				result.push(separator);
-			}
-			result.push(chunk);
-		}
-		return new SQL(result);
-	}
-
-	/**
-	 * Create a SQL chunk that represents a DB identifier (table, column, index etc.).
-	 * When used in a query, the identifier will be escaped based on the DB engine.
-	 * For example, in PostgreSQL, identifiers are escaped with double quotes.
-	 *
-	 * **WARNING: This function does not offer any protection against SQL injections, so you must validate any user input beforehand.**
-	 *
-	 * @example ```ts
-	 * const query = sql`SELECT * FROM ${sql.identifier('my-table')}`;
-	 * // 'SELECT * FROM "my-table"'
-	 * ```
-	 */
-	export function identifier(value: string): Name {
-		return new Name(value);
-	}
-
-	export function placeholder<TName extends string>(name: TName): Placeholder<TName> {
-		return new Placeholder(name);
-	}
-
-	export function param<TData, TDriver>(
-		value: TData,
-		encoder?: DriverValueEncoder<TData, TDriver>,
-	): Param<TData, TDriver> {
-		return new Param(value, encoder);
-	}
-}
-
-export namespace SQL {
-	export class Aliased<T = unknown> implements SQLWrapper {
-		static readonly [entityKind]: string = 'SQL.Aliased';
-
-		declare _: {
-			brand: 'SQL.Aliased';
-			type: T;
-		};
-
-		/** @internal */
-		isSelectionField = false;
-
-		constructor(
-			readonly sql: SQL,
-			readonly fieldAlias: string,
-		) {}
-
-		getSQL(): SQL {
-			return this.sql;
-		}
-
-		/** @internal */
-		clone() {
-			return new Aliased(this.sql, this.fieldAlias);
-		}
-	}
-}
-
-export class Placeholder<TName extends string = string, TValue = any> implements SQLWrapper {
-	static readonly [entityKind]: string = 'Placeholder';
-
-	declare protected: TValue;
-
-	constructor(readonly name: TName) {}
-
-	getSQL(): SQL {
-		return new SQL([this]);
-	}
-}
-
-/** @deprecated Use `sql.placeholder` instead. */
-export function placeholder<TName extends string>(name: TName): Placeholder<TName> {
-	return new Placeholder(name);
-}
-
-export function fillPlaceholders(params: unknown[], values: Record<string, unknown>): unknown[] {
-	return params.map((p) => {
-		if (is(p, Placeholder)) {
-			if (!(p.name in values)) {
-				throw new Error(`No value for placeholder "${p.name}" was provided`);
-			}
-			return values[p.name];
-		}
-
-		return p;
-	});
-}
-
-// Defined separately from the Column class to resolve circular dependency
-Column.prototype.getSQL = function() {
-	return new SQL([this]);
-};
+export * from './sql.ts';
diff --git a/drizzle-orm/src/sql/sql.ts b/drizzle-orm/src/sql/sql.ts
new file mode 100644
index 000000000..cb92da20c
--- /dev/null
+++ b/drizzle-orm/src/sql/sql.ts
@@ -0,0 +1,584 @@
+import { entityKind, is } from '~/entity.ts';
+import { Relation } from '~/relations.ts';
+import { Subquery, SubqueryConfig } from '~/subquery.ts';
+import { tracer } from '~/tracing.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import { View } from '~/view.ts';
+import type { AnyColumn } from '../column.ts';
+import { Column } from '../column.ts';
+import { Table } from '../table.ts';
+
+/**
+ * This class is used to indicate a primitive param value that is used in `sql` tag.
+ * It is only used on type level and is never instantiated at runtime.
+ * If you see a value of this type in the code, its runtime value is actually the primitive param value.
+ */
+export class FakePrimitiveParam {
+	static readonly [entityKind]: string = 'FakePrimitiveParam';
+}
+
+export type Chunk =
+	| string
+	| Table
+	| View
+	| AnyColumn
+	| Name
+	| Param
+	| Placeholder
+	| SQL;
+
+export interface BuildQueryConfig {
+	escapeName(name: string): string;
+	escapeParam(num: number, value: unknown): string;
+	escapeString(str: string): string;
+	prepareTyping?: (encoder: DriverValueEncoder<unknown, unknown>) => QueryTypingsValue;
+	paramStartIndex?: { value: number };
+	inlineParams?: boolean;
+}
+
+export type QueryTypingsValue = 'json' | 'decimal' | 'time' | 'timestamp' | 'uuid' | 'date' | 'none';
+
+export interface Query {
+	sql: string;
+	params: unknown[];
+}
+
+export interface QueryWithTypings extends Query {
+	typings?: QueryTypingsValue[];
+}
+
+/**
+ * Any value that implements the `getSQL` method. The implementations include:
+ * - `Table`
+ * - `Column`
+ * - `View`
+ * - `Subquery`
+ * - `SQL`
+ * - `SQL.Aliased`
+ * - `Placeholder`
+ * - `Param`
+ */
+export interface SQLWrapper {
+	getSQL(): SQL;
+}
+
+export function isSQLWrapper(value: unknown): value is SQLWrapper {
+	return typeof value === 'object' && value !== null && 'getSQL' in value
+		&& typeof (value as any).getSQL === 'function';
+}
+
+function mergeQueries(queries: QueryWithTypings[]): QueryWithTypings {
+	const result: QueryWithTypings = { sql: '', params: [] };
+	for (const query of queries) {
+		result.sql += query.sql;
+		result.params.push(...query.params);
+		if (query.typings?.length) {
+			if (!result.typings) {
+				result.typings = [];
+			}
+			result.typings.push(...query.typings);
+		}
+	}
+	return result;
+}
+
+export class StringChunk implements SQLWrapper {
+	static readonly [entityKind]: string = 'StringChunk';
+
+	readonly value: string[];
+
+	constructor(value: string | string[]) {
+		this.value = Array.isArray(value) ? value : [value];
+	}
+
+	getSQL(): SQL<unknown> {
+		return new SQL([this]);
+	}
+}
+
+export class SQL<T = unknown> implements SQLWrapper {
+	static readonly [entityKind]: string = 'SQL';
+
+	declare _: {
+		brand: 'SQL';
+		type: T;
+	};
+
+	/** @internal */
+	decoder: DriverValueDecoder<T, any> = noopDecoder;
+	private shouldInlineParams = false;
+
+	constructor(readonly queryChunks: SQLChunk[]) {}
+
+	append(query: SQL): this {
+		this.queryChunks.push(...query.queryChunks);
+		return this;
+	}
+
+	toQuery(config: BuildQueryConfig): QueryWithTypings {
+		return tracer.startActiveSpan('drizzle.buildSQL', (span) => {
+			const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+			span?.setAttributes({
+				'drizzle.query.text': query.sql,
+				'drizzle.query.params': JSON.stringify(query.params),
+			});
+			return query;
+		});
+	}
+
+	buildQueryFromSourceParams(chunks: SQLChunk[], _config: BuildQueryConfig): Query {
+		const config = Object.assign({}, _config, {
+			inlineParams: _config.inlineParams || this.shouldInlineParams,
+			paramStartIndex: _config.paramStartIndex || { value: 0 },
+		});
+
+		const {
+			escapeName,
+			escapeParam,
+			prepareTyping,
+			inlineParams,
+			paramStartIndex,
+		} = config;
+
+		return mergeQueries(chunks.map((chunk): QueryWithTypings => {
+			if (is(chunk, StringChunk)) {
+				return { sql: chunk.value.join(''), params: [] };
+			}
+
+			if (is(chunk, Name)) {
+				return { sql: escapeName(chunk.value), params: [] };
+			}
+
+			if (chunk === undefined) {
+				return { sql: '', params: [] };
+			}
+
+			if (Array.isArray(chunk)) {
+				const result: SQLChunk[] = [new StringChunk('(')];
+				for (const [i, p] of chunk.entries()) {
+					result.push(p);
+					if (i < chunk.length - 1) {
+						result.push(new StringChunk(', '));
+					}
+				}
+				result.push(new StringChunk(')'));
+				return this.buildQueryFromSourceParams(result, config);
+			}
+
+			if (is(chunk, SQL)) {
+				return this.buildQueryFromSourceParams(chunk.queryChunks, {
+					...config,
+					inlineParams: inlineParams || chunk.shouldInlineParams,
+				});
+			}
+
+			if (is(chunk, Table)) {
+				const schemaName = chunk[Table.Symbol.Schema];
+				const tableName = chunk[Table.Symbol.Name];
+				return {
+					sql: schemaName === undefined
+						? escapeName(tableName)
+						: escapeName(schemaName) + '.' + escapeName(tableName),
+					params: [],
+				};
+			}
+
+			if (is(chunk, Column)) {
+				return { sql: escapeName(chunk.table[Table.Symbol.Name]) + '.' + escapeName(chunk.name), params: [] };
+			}
+
+			if (is(chunk, View)) {
+				const schemaName = chunk[ViewBaseConfig].schema;
+				const viewName = chunk[ViewBaseConfig].name;
+				return {
+					sql: schemaName === undefined
+						? escapeName(viewName)
+						: escapeName(schemaName) + '.' + escapeName(viewName),
+					params: [],
+				};
+			}
+
+			if (is(chunk, Param)) {
+				const mappedValue = (chunk.value === null) ? null : chunk.encoder.mapToDriverValue(chunk.value);
+
+				if (is(mappedValue, SQL)) {
+					return this.buildQueryFromSourceParams([mappedValue], config);
+				}
+
+				if (inlineParams) {
+					return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+				}
+
+				let typings: QueryTypingsValue[] | undefined;
+				if (prepareTyping !== undefined) {
+					typings = [prepareTyping(chunk.encoder)];
+				}
+
+				return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+			}
+
+			if (is(chunk, Placeholder)) {
+				return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
+			}
+
+			if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+				return { sql: escapeName(chunk.fieldAlias), params: [] };
+			}
+
+			if (is(chunk, Subquery)) {
+				if (chunk[SubqueryConfig].isWith) {
+					return { sql: escapeName(chunk[SubqueryConfig].alias), params: [] };
+				}
+				return this.buildQueryFromSourceParams([
+					new StringChunk('('),
+					chunk[SubqueryConfig].sql,
+					new StringChunk(') '),
+					new Name(chunk[SubqueryConfig].alias),
+				], config);
+			}
+
+			// if (is(chunk, Placeholder)) {
+			// 	return {sql: escapeParam}
+
+			if (isSQLWrapper(chunk)) {
+				return this.buildQueryFromSourceParams([
+					new StringChunk('('),
+					chunk.getSQL(),
+					new StringChunk(')'),
+				], config);
+			}
+
+			if (is(chunk, Relation)) {
+				return this.buildQueryFromSourceParams([
+					chunk.sourceTable,
+					new StringChunk('.'),
+					sql.identifier(chunk.fieldName),
+				], config);
+			}
+
+			if (inlineParams) {
+				return { sql: this.mapInlineParam(chunk, config), params: [] };
+			}
+
+			return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
+		}));
+	}
+
+	private mapInlineParam(
+		chunk: unknown,
+		{ escapeString }: BuildQueryConfig,
+	): string {
+		if (chunk === null) {
+			return 'null';
+		}
+		if (typeof chunk === 'number' || typeof chunk === 'boolean') {
+			return chunk.toString();
+		}
+		if (typeof chunk === 'string') {
+			return escapeString(chunk);
+		}
+		if (typeof chunk === 'object') {
+			const mappedValueAsString = chunk.toString();
+			if (mappedValueAsString === '[object Object]') {
+				return escapeString(JSON.stringify(chunk));
+			}
+			return escapeString(mappedValueAsString);
+		}
+		throw new Error('Unexpected param value: ' + chunk);
+	}
+
+	getSQL(): SQL {
+		return this;
+	}
+
+	as(alias: string): SQL.Aliased<T>;
+	/**
+	 * @deprecated
+	 * Use ``sql<DataType>`query`.as(alias)`` instead.
+	 */
+	as<TData>(): SQL<TData>;
+	/**
+	 * @deprecated
+	 * Use ``sql<DataType>`query`.as(alias)`` instead.
+	 */
+	as<TData>(alias: string): SQL.Aliased<TData>;
+	as(alias?: string): SQL<T> | SQL.Aliased<T> {
+		// TODO: remove with deprecated overloads
+		if (alias === undefined) {
+			return this;
+		}
+
+		return new SQL.Aliased(this, alias);
+	}
+
+	mapWith<
+		TDecoder extends
+			| DriverValueDecoder<any, any>
+			| DriverValueDecoder<any, any>['mapFromDriverValue'],
+	>(decoder: TDecoder): SQL<GetDecoderResult<TDecoder>> {
+		this.decoder = typeof decoder === 'function' ? { mapFromDriverValue: decoder } : decoder;
+		return this as SQL<GetDecoderResult<TDecoder>>;
+	}
+
+	inlineParams(): this {
+		this.shouldInlineParams = true;
+		return this;
+	}
+}
+
+export type GetDecoderResult<T> = T extends Column ? T['_']['data'] : T extends
+	| DriverValueDecoder<infer TData, any>
+	| DriverValueDecoder<infer TData, any>['mapFromDriverValue'] ? TData
+: never;
+
+/**
+ * Any DB name (table, column, index etc.)
+ */
+export class Name implements SQLWrapper {
+	static readonly [entityKind]: string = 'Name';
+
+	protected brand!: 'Name';
+
+	constructor(readonly value: string) {}
+
+	getSQL(): SQL<unknown> {
+		return new SQL([this]);
+	}
+}
+
+/**
+ * Any DB name (table, column, index etc.)
+ * @deprecated Use `sql.identifier` instead.
+ */
+export function name(value: string): Name {
+	return new Name(value);
+}
+
+export interface DriverValueDecoder<TData, TDriverParam> {
+	mapFromDriverValue(value: TDriverParam): TData;
+}
+
+export interface DriverValueEncoder<TData, TDriverParam> {
+	mapToDriverValue(value: TData): TDriverParam | SQL;
+}
+
+export function isDriverValueEncoder(value: unknown): value is DriverValueEncoder<any, any> {
+	return typeof value === 'object' && value !== null && 'mapToDriverValue' in value
+		&& typeof (value as any).mapToDriverValue === 'function';
+}
+
+export const noopDecoder: DriverValueDecoder<any, any> = {
+	mapFromDriverValue: (value) => value,
+};
+
+export const noopEncoder: DriverValueEncoder<any, any> = {
+	mapToDriverValue: (value) => value,
+};
+
+export interface DriverValueMapper<TData, TDriverParam>
+	extends DriverValueDecoder<TData, TDriverParam>, DriverValueEncoder<TData, TDriverParam>
+{}
+
+export const noopMapper: DriverValueMapper<any, any> = {
+	...noopDecoder,
+	...noopEncoder,
+};
+
+/** Parameter value that is optionally bound to an encoder (for example, a column). */
+export class Param<TDataType = unknown, TDriverParamType = TDataType> implements SQLWrapper {
+	static readonly [entityKind]: string = 'Param';
+
+	protected brand!: 'BoundParamValue';
+
+	/**
+	 * @param value - Parameter value
+	 * @param encoder - Encoder to convert the value to a driver parameter
+	 */
+	constructor(
+		readonly value: TDataType,
+		readonly encoder: DriverValueEncoder<TDataType, TDriverParamType> = noopEncoder,
+	) {}
+
+	getSQL(): SQL<unknown> {
+		return new SQL([this]);
+	}
+}
+
+/** @deprecated Use `sql.param` instead. */
+export function param<TData, TDriver>(
+	value: TData,
+	encoder?: DriverValueEncoder<TData, TDriver>,
+): Param<TData, TDriver> {
+	return new Param(value, encoder);
+}
+
+/**
+ * Anything that can be passed to the `` sql`...` `` tagged function.
+ */
+export type SQLChunk =
+	| StringChunk
+	| SQLChunk[]
+	| SQLWrapper
+	| SQL
+	| Table
+	| View
+	| Subquery
+	| AnyColumn
+	| Param
+	| Name
+	| undefined
+	| FakePrimitiveParam
+	| Placeholder;
+
+export function sql<T>(strings: TemplateStringsArray, ...params: any[]): SQL<T>;
+/*
+	The type of `params` is specified as `SQLSourceParam[]`, but that's slightly incorrect -
+	in runtime, users won't pass `FakePrimitiveParam` instances as `params` - they will pass primitive values
+	which will be wrapped in `Param` using `buildChunksFromParam(...)`. That's why the overload
+	specify `params` as `any[]` and not as `SQLSourceParam[]`. This type is used to make our lives easier and
+	the type checker happy.
+*/
+export function sql(strings: TemplateStringsArray, ...params: SQLChunk[]): SQL {
+	const queryChunks: SQLChunk[] = [];
+	if (params.length > 0 || (strings.length > 0 && strings[0] !== '')) {
+		queryChunks.push(new StringChunk(strings[0]!));
+	}
+	for (const [paramIndex, param] of params.entries()) {
+		queryChunks.push(param, new StringChunk(strings[paramIndex + 1]!));
+	}
+
+	return new SQL(queryChunks);
+}
+
+export namespace sql {
+	export function empty(): SQL {
+		return new SQL([]);
+	}
+
+	/** @deprecated - use `sql.join()` */
+	export function fromList(list: SQLChunk[]): SQL {
+		return new SQL(list);
+	}
+
+	/**
+	 * Convenience function to create an SQL query from a raw string.
+	 * @param str The raw SQL query string.
+	 */
+	export function raw(str: string): SQL {
+		return new SQL([new StringChunk(str)]);
+	}
+
+	/**
+	 * Join a list of SQL chunks with a separator.
+	 * @example
+	 * ```ts
+	 * const query = sql.join([sql`a`, sql`b`, sql`c`]);
+	 * // sql`abc`
+	 * ```
+	 * @example
+	 * ```ts
+	 * const query = sql.join([sql`a`, sql`b`, sql`c`], sql`, `);
+	 * // sql`a, b, c`
+	 * ```
+	 */
+	export function join(chunks: SQLChunk[], separator?: SQLChunk): SQL {
+		const result: SQLChunk[] = [];
+		for (const [i, chunk] of chunks.entries()) {
+			if (i > 0 && separator !== undefined) {
+				result.push(separator);
+			}
+			result.push(chunk);
+		}
+		return new SQL(result);
+	}
+
+	/**
+	 * Create a SQL chunk that represents a DB identifier (table, column, index etc.).
+	 * When used in a query, the identifier will be escaped based on the DB engine.
+	 * For example, in PostgreSQL, identifiers are escaped with double quotes.
+	 *
+	 * **WARNING: This function does not offer any protection against SQL injections, so you must validate any user input beforehand.**
+	 *
+	 * @example ```ts
+	 * const query = sql`SELECT * FROM ${sql.identifier('my-table')}`;
+	 * // 'SELECT * FROM "my-table"'
+	 * ```
+	 */
+	export function identifier(value: string): Name {
+		return new Name(value);
+	}
+
+	export function placeholder<TName extends string>(name: TName): Placeholder<TName> {
+		return new Placeholder(name);
+	}
+
+	export function param<TData, TDriver>(
+		value: TData,
+		encoder?: DriverValueEncoder<TData, TDriver>,
+	): Param<TData, TDriver> {
+		return new Param(value, encoder);
+	}
+}
+
+export namespace SQL {
+	export class Aliased<T = unknown> implements SQLWrapper {
+		static readonly [entityKind]: string = 'SQL.Aliased';
+
+		declare _: {
+			brand: 'SQL.Aliased';
+			type: T;
+		};
+
+		/** @internal */
+		isSelectionField = false;
+
+		constructor(
+			readonly sql: SQL,
+			readonly fieldAlias: string,
+		) {}
+
+		getSQL(): SQL {
+			return this.sql;
+		}
+
+		/** @internal */
+		clone() {
+			return new Aliased(this.sql, this.fieldAlias);
+		}
+	}
+}
+
+export class Placeholder<TName extends string = string, TValue = any> implements SQLWrapper {
+	static readonly [entityKind]: string = 'Placeholder';
+
+	declare protected: TValue;
+
+	constructor(readonly name: TName) {}
+
+	getSQL(): SQL {
+		return new SQL([this]);
+	}
+}
+
+/** @deprecated Use `sql.placeholder` instead. */
+export function placeholder<TName extends string>(name: TName): Placeholder<TName> {
+	return new Placeholder(name);
+}
+
+export function fillPlaceholders(params: unknown[], values: Record<string, unknown>): unknown[] {
+	return params.map((p) => {
+		if (is(p, Placeholder)) {
+			if (!(p.name in values)) {
+				throw new Error(`No value for placeholder "${p.name}" was provided`);
+			}
+			return values[p.name];
+		}
+
+		return p;
+	});
+}
+
+// Defined separately from the Column class to resolve circular dependency
+Column.prototype.getSQL = function() {
+	return new SQL([this]);
+};
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index 2744459ed..c6e64da60 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -23,7 +23,7 @@ import { SQLiteTable } from '~/sqlite-core/table.ts';
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
-import { ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
 import type {
 	SelectedFieldsOrdered,
 	SQLiteSelectConfig,
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.ts b/drizzle-orm/src/sqlite-core/query-builders/select.ts
index 0502b88bf..a8e0f72bf 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.ts
@@ -20,7 +20,8 @@ import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
 import { applyMixins, getTableColumns, getTableLikeName, orderSelectedFields, type ValueOrArray } from '~/utils.ts';
-import { type ColumnsSelection, View, ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
+import { type ColumnsSelection, View } from '~/view.ts';
 import { SQLiteViewBase } from '../view.ts';
 import type {
 	CreateSQLiteSelectFromBuilderMode,
diff --git a/drizzle-orm/src/sqlite-core/unique-constraint.ts b/drizzle-orm/src/sqlite-core/unique-constraint.ts
index 136280d79..83dfcebdd 100644
--- a/drizzle-orm/src/sqlite-core/unique-constraint.ts
+++ b/drizzle-orm/src/sqlite-core/unique-constraint.ts
@@ -1,5 +1,5 @@
 import { entityKind } from '~/entity.ts';
-import { type SQLiteColumn } from './columns/index.ts';
+import type { SQLiteColumn } from './columns/common.ts';
 import { SQLiteTable } from './table.ts';
 
 export function uniqueKeyName(table: SQLiteTable, columns: string[]) {
diff --git a/drizzle-orm/src/sqlite-core/utils.ts b/drizzle-orm/src/sqlite-core/utils.ts
index 0d06dc8ef..2312466c4 100644
--- a/drizzle-orm/src/sqlite-core/utils.ts
+++ b/drizzle-orm/src/sqlite-core/utils.ts
@@ -1,6 +1,6 @@
 import { is } from '~/entity.ts';
 import { Table } from '~/table.ts';
-import { ViewBaseConfig } from '~/view.ts';
+import { ViewBaseConfig } from '~/view-common.ts';
 import type { Check } from './checks.ts';
 import { CheckBuilder } from './checks.ts';
 import type { ForeignKey } from './foreign-keys.ts';
@@ -11,7 +11,8 @@ import type { PrimaryKey } from './primary-keys.ts';
 import { PrimaryKeyBuilder } from './primary-keys.ts';
 import { SQLiteTable } from './table.ts';
 import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
-import { type SQLiteView, SQLiteViewConfig } from './view.ts';
+import { SQLiteViewConfig } from './view-common.ts';
+import type { SQLiteView } from './view.ts';
 
 export function getTableConfig<TTable extends SQLiteTable>(table: TTable) {
 	const columns = Object.values(table[SQLiteTable.Symbol.Columns]);
diff --git a/drizzle-orm/src/sqlite-core/view-common.ts b/drizzle-orm/src/sqlite-core/view-common.ts
new file mode 100644
index 000000000..ed1c08c96
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/view-common.ts
@@ -0,0 +1 @@
+export const SQLiteViewConfig = Symbol.for('drizzle:SQLiteViewConfig');
diff --git a/drizzle-orm/src/sqlite-core/view.ts b/drizzle-orm/src/sqlite-core/view.ts
index 8b040ba9e..2a51c2ffa 100644
--- a/drizzle-orm/src/sqlite-core/view.ts
+++ b/drizzle-orm/src/sqlite-core/view.ts
@@ -7,9 +7,10 @@ import { SelectionProxyHandler } from '~/subquery.ts';
 import { getTableColumns } from '~/utils.ts';
 import { type ColumnsSelection, View } from '~/view.ts';
 import type { SQLiteColumn, SQLiteColumnBuilderBase } from './columns/common.ts';
-import { QueryBuilder } from './query-builders/index.ts';
+import { QueryBuilder } from './query-builders/query-builder.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { sqliteTable } from './table.ts';
+import { SQLiteViewConfig } from './view-common.ts';
 
 export interface ViewBuilderConfig {
 	algorithm?: 'undefined' | 'merge' | 'temptable';
@@ -138,8 +139,6 @@ export abstract class SQLiteViewBase<
 	};
 }
 
-export const SQLiteViewConfig = Symbol.for('drizzle:SQLiteViewConfig');
-
 export class SQLiteView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
diff --git a/drizzle-orm/src/sqlite-proxy/session.ts b/drizzle-orm/src/sqlite-proxy/session.ts
index 6b0bef077..b27c6c492 100644
--- a/drizzle-orm/src/sqlite-proxy/session.ts
+++ b/drizzle-orm/src/sqlite-proxy/session.ts
@@ -1,7 +1,7 @@
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
@@ -13,7 +13,7 @@ import type {
 } from '~/sqlite-core/session.ts';
 import { SQLitePreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
-import { type RemoteCallback, type SqliteRemoteResult } from './driver.ts';
+import type { RemoteCallback, SqliteRemoteResult } from './driver.ts';
 
 export interface SQLiteRemoteSessionOptions {
 	logger?: Logger;
diff --git a/drizzle-orm/src/subquery.ts b/drizzle-orm/src/subquery.ts
index 094a075be..8e1413528 100644
--- a/drizzle-orm/src/subquery.ts
+++ b/drizzle-orm/src/subquery.ts
@@ -2,7 +2,8 @@ import { ColumnAliasProxyHandler, TableAliasProxyHandler } from './alias.ts';
 import { Column } from './column.ts';
 import { entityKind, is } from './entity.ts';
 import { SQL, type SQLWrapper } from './sql/index.ts';
-import { type ColumnsSelection, View, ViewBaseConfig } from './view.ts';
+import { ViewBaseConfig } from './view-common.ts';
+import { type ColumnsSelection, View } from './view.ts';
 
 export const SubqueryConfig = Symbol.for('drizzle:SubqueryConfig');
 
diff --git a/drizzle-orm/src/table.ts b/drizzle-orm/src/table.ts
index 82e34f4e6..5ba5bcddb 100644
--- a/drizzle-orm/src/table.ts
+++ b/drizzle-orm/src/table.ts
@@ -1,8 +1,8 @@
 import type { Column, GetColumnData } from './column.ts';
 import { entityKind } from './entity.ts';
 import type { OptionalKeyOnly, RequiredKeyOnly } from './operations.ts';
-import { SQL, type SQLWrapper } from './sql/index.ts';
-import { type Simplify, type Update } from './utils.ts';
+import { SQL, type SQLWrapper } from './sql/sql.ts';
+import type { Simplify, Update } from './utils.ts';
 
 export interface TableConfig<TColumn extends Column = Column<any>> {
 	name: string;
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index dc71112eb..a2adc01f6 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -8,7 +8,8 @@ import { Param, SQL } from './sql/index.ts';
 import type { DriverValueDecoder } from './sql/index.ts';
 import { Subquery, SubqueryConfig } from './subquery.ts';
 import { getTableName, Table } from './table.ts';
-import { View, ViewBaseConfig } from './view.ts';
+import { ViewBaseConfig } from './view-common.ts';
+import { View } from './view.ts';
 
 /** @internal */
 export function mapResultRow<TResult>(
diff --git a/drizzle-orm/src/view-common.ts b/drizzle-orm/src/view-common.ts
new file mode 100644
index 000000000..f1537fb1b
--- /dev/null
+++ b/drizzle-orm/src/view-common.ts
@@ -0,0 +1 @@
+export const ViewBaseConfig = Symbol.for('drizzle:ViewBaseConfig');
diff --git a/drizzle-orm/src/view.ts b/drizzle-orm/src/view.ts
index 28b912432..bd1485bda 100644
--- a/drizzle-orm/src/view.ts
+++ b/drizzle-orm/src/view.ts
@@ -3,8 +3,7 @@ import { entityKind } from './entity.ts';
 import type { SelectedFields } from './operations.ts';
 import { SQL, type SQLWrapper } from './sql/index.ts';
 import type { Table } from './table.ts';
-
-export const ViewBaseConfig = Symbol.for('drizzle:ViewBaseConfig');
+import { ViewBaseConfig } from './view-common.ts';
 
 export type ColumnsSelection = Record<string, unknown>;
 
diff --git a/drizzle-typebox/tests/utils.ts b/drizzle-typebox/tests/utils.ts
index a98bfd961..0454dd48d 100644
--- a/drizzle-typebox/tests/utils.ts
+++ b/drizzle-typebox/tests/utils.ts
@@ -1,5 +1,5 @@
 import type { TSchema } from '@sinclair/typebox';
-import { type ExecutionContext } from 'ava';
+import type { ExecutionContext } from 'ava';
 
 export function expectSchemaShape<T extends TSchema>(t: ExecutionContext, expected: T) {
 	return {
@@ -15,4 +15,3 @@ export function expectSchemaShape<T extends TSchema>(t: ExecutionContext, expect
 		},
 	};
 }
-
diff --git a/drizzle-valibot/tests/utils.ts b/drizzle-valibot/tests/utils.ts
index 1464847cb..0d38bc534 100644
--- a/drizzle-valibot/tests/utils.ts
+++ b/drizzle-valibot/tests/utils.ts
@@ -1,5 +1,5 @@
 import { type ExecutionContext } from 'ava';
-import { type BaseSchema } from 'valibot';
+import type { BaseSchema } from 'valibot';
 
 export function expectSchemaShape<T extends BaseSchema<any, any>>(t: ExecutionContext, expected: T) {
 	return {
@@ -8,4 +8,3 @@ export function expectSchemaShape<T extends BaseSchema<any, any>>(t: ExecutionCo
 		},
 	};
 }
-
diff --git a/drizzle-zod/tests/utils.ts b/drizzle-zod/tests/utils.ts
index c30c9b243..b8daf972e 100644
--- a/drizzle-zod/tests/utils.ts
+++ b/drizzle-zod/tests/utils.ts
@@ -1,4 +1,4 @@
-import { type ExecutionContext } from 'ava';
+import type { ExecutionContext } from 'ava';
 import type { z } from 'zod';
 
 export function expectSchemaShape<T extends z.ZodRawShape>(t: ExecutionContext, expected: z.ZodObject<T>) {

From 1a05cb8ba925575fe496b6b6a4c9722f705a30a4 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Fri, 13 Oct 2023 01:34:57 +0300
Subject: [PATCH 39/72] Resolve more circular dependencies

---
 drizzle-orm/src/column.ts                 |  4 +-
 drizzle-orm/src/pg-core/columns/array.ts  | 92 -----------------------
 drizzle-orm/src/pg-core/columns/common.ts | 85 ++++++++++++++++++++-
 drizzle-orm/src/pg-core/columns/index.ts  |  1 -
 drizzle-orm/src/sql/sql.ts                |  5 ++
 drizzle-orm/src/table.ts                  | 13 ++--
 6 files changed, 99 insertions(+), 101 deletions(-)
 delete mode 100644 drizzle-orm/src/pg-core/columns/array.ts

diff --git a/drizzle-orm/src/column.ts b/drizzle-orm/src/column.ts
index 836d32700..1582ba825 100644
--- a/drizzle-orm/src/column.ts
+++ b/drizzle-orm/src/column.ts
@@ -38,7 +38,9 @@ export interface Column<
 	TRuntimeConfig extends object = object,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TTypeConfig extends object = object,
-> extends DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {}
+> extends DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
 /*
 	`Column` only accepts a full `ColumnConfig` as its generic.
 	To infer parts of the config, use `AnyColumn` that accepts a partial config.
diff --git a/drizzle-orm/src/pg-core/columns/array.ts b/drizzle-orm/src/pg-core/columns/array.ts
deleted file mode 100644
index cef68999e..000000000
--- a/drizzle-orm/src/pg-core/columns/array.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import type {
-	ColumnBuilderBaseConfig,
-	ColumnBuilderRuntimeConfig,
-	ColumnDataType,
-	MakeColumnConfig,
-} from '~/column-builder.ts';
-import type { ColumnBaseConfig } from '~/column.ts';
-import { entityKind, is } from '~/entity.ts';
-import type { AnyPgTable } from '~/pg-core/table.ts';
-import { makePgArray, parsePgArray } from '../utils/array.ts';
-import { PgColumn, PgColumnBuilder } from './common.ts';
-
-export class PgArrayBuilder<
-	T extends ColumnBuilderBaseConfig<'array', 'PgArray'>,
-	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-> extends PgColumnBuilder<
-	T,
-	{
-		baseBuilder: PgColumnBuilder<TBase>;
-		size: number | undefined;
-	},
-	{
-		baseBuilder: PgColumnBuilder<TBase>;
-	}
-> {
-	static override readonly [entityKind] = 'PgArrayBuilder';
-
-	constructor(
-		name: string,
-		baseBuilder: PgArrayBuilder<T, TBase>['config']['baseBuilder'],
-		size: number | undefined,
-	) {
-		super(name, 'array', 'PgArray');
-		this.config.baseBuilder = baseBuilder;
-		this.config.size = size;
-	}
-
-	/** @internal */
-	override build<TTableName extends string>(
-		table: AnyPgTable<{ name: TTableName }>,
-	): PgArray<MakeColumnConfig<T, TTableName>, TBase> {
-		const baseColumn = this.config.baseBuilder.build(table);
-		return new PgArray<MakeColumnConfig<T, TTableName>, TBase>(
-			table as AnyPgTable<{ name: MakeColumnConfig<T, TTableName>['tableName'] }>,
-			this.config as ColumnBuilderRuntimeConfig<any, any>,
-			baseColumn,
-		);
-	}
-}
-
-export class PgArray<
-	T extends ColumnBaseConfig<'array', 'PgArray'>,
-	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string>,
-> extends PgColumn<T> {
-	readonly size: number | undefined;
-
-	static readonly [entityKind]: string = 'PgArray';
-
-	constructor(
-		table: AnyPgTable<{ name: T['tableName'] }>,
-		config: PgArrayBuilder<T, TBase>['config'],
-		readonly baseColumn: PgColumn,
-		readonly range?: [number | undefined, number | undefined],
-	) {
-		super(table, config);
-		this.size = config.size;
-	}
-
-	getSQLType(): string {
-		return `${this.baseColumn.getSQLType()}[${typeof this.size === 'number' ? this.size : ''}]`;
-	}
-
-	override mapFromDriverValue(value: unknown[] | string): T['data'] {
-		if (typeof value === 'string') {
-			// Thank you node-postgres for not parsing enum arrays
-			value = parsePgArray(value);
-		}
-		return value.map((v) => this.baseColumn.mapFromDriverValue(v));
-	}
-
-	override mapToDriverValue(value: unknown[], isNestedArray = false): unknown[] | string {
-		const a = value.map((v) =>
-			v === null
-				? null
-				: is(this.baseColumn, PgArray)
-				? this.baseColumn.mapToDriverValue(v as unknown[], true)
-				: this.baseColumn.mapToDriverValue(v)
-		);
-		if (isNestedArray) return a;
-		return makePgArray(a);
-	}
-}
diff --git a/drizzle-orm/src/pg-core/columns/common.ts b/drizzle-orm/src/pg-core/columns/common.ts
index 6e71fec17..94f7d2310 100644
--- a/drizzle-orm/src/pg-core/columns/common.ts
+++ b/drizzle-orm/src/pg-core/columns/common.ts
@@ -9,14 +9,14 @@ import type {
 import { ColumnBuilder } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { Column } from '~/column.ts';
-import { entityKind } from '~/entity.ts';
+import { entityKind, is } from '~/entity.ts';
 import { iife, type Update } from '~/utils.ts';
 
 import type { ForeignKey, UpdateDeleteAction } from '~/pg-core/foreign-keys.ts';
 import { ForeignKeyBuilder } from '~/pg-core/foreign-keys.ts';
 import type { AnyPgTable, PgTable } from '~/pg-core/table.ts';
 import { uniqueKeyName } from '../unique-constraint.ts';
-import { PgArrayBuilder } from './array.ts';
+import { makePgArray, parsePgArray } from '../utils/array.ts';
 
 export interface ReferenceConfig {
 	ref: () => PgColumn;
@@ -128,3 +128,84 @@ export abstract class PgColumn<
 export type AnyPgColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = PgColumn<
 	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
 >;
+
+export class PgArrayBuilder<
+	T extends ColumnBuilderBaseConfig<'array', 'PgArray'>,
+	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+> extends PgColumnBuilder<
+	T,
+	{
+		baseBuilder: PgColumnBuilder<TBase>;
+		size: number | undefined;
+	},
+	{
+		baseBuilder: PgColumnBuilder<TBase>;
+	}
+> {
+	static override readonly [entityKind] = 'PgArrayBuilder';
+
+	constructor(
+		name: string,
+		baseBuilder: PgArrayBuilder<T, TBase>['config']['baseBuilder'],
+		size: number | undefined,
+	) {
+		super(name, 'array', 'PgArray');
+		this.config.baseBuilder = baseBuilder;
+		this.config.size = size;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgArray<MakeColumnConfig<T, TTableName>, TBase> {
+		const baseColumn = this.config.baseBuilder.build(table);
+		return new PgArray<MakeColumnConfig<T, TTableName>, TBase>(
+			table as AnyPgTable<{ name: MakeColumnConfig<T, TTableName>['tableName'] }>,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+			baseColumn,
+		);
+	}
+}
+
+export class PgArray<
+	T extends ColumnBaseConfig<'array', 'PgArray'>,
+	TBase extends ColumnBuilderBaseConfig<ColumnDataType, string>,
+> extends PgColumn<T> {
+	readonly size: number | undefined;
+
+	static readonly [entityKind]: string = 'PgArray';
+
+	constructor(
+		table: AnyPgTable<{ name: T['tableName'] }>,
+		config: PgArrayBuilder<T, TBase>['config'],
+		readonly baseColumn: PgColumn,
+		readonly range?: [number | undefined, number | undefined],
+	) {
+		super(table, config);
+		this.size = config.size;
+	}
+
+	getSQLType(): string {
+		return `${this.baseColumn.getSQLType()}[${typeof this.size === 'number' ? this.size : ''}]`;
+	}
+
+	override mapFromDriverValue(value: unknown[] | string): T['data'] {
+		if (typeof value === 'string') {
+			// Thank you node-postgres for not parsing enum arrays
+			value = parsePgArray(value);
+		}
+		return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+	}
+
+	override mapToDriverValue(value: unknown[], isNestedArray = false): unknown[] | string {
+		const a = value.map((v) =>
+			v === null
+				? null
+				: is(this.baseColumn, PgArray)
+				? this.baseColumn.mapToDriverValue(v as unknown[], true)
+				: this.baseColumn.mapToDriverValue(v)
+		);
+		if (isNestedArray) return a;
+		return makePgArray(a);
+	}
+}
diff --git a/drizzle-orm/src/pg-core/columns/index.ts b/drizzle-orm/src/pg-core/columns/index.ts
index a87315a1f..7e2a52c2e 100644
--- a/drizzle-orm/src/pg-core/columns/index.ts
+++ b/drizzle-orm/src/pg-core/columns/index.ts
@@ -1,4 +1,3 @@
-export * from './array.ts';
 export * from './bigint.ts';
 export * from './bigserial.ts';
 export * from './boolean.ts';
diff --git a/drizzle-orm/src/sql/sql.ts b/drizzle-orm/src/sql/sql.ts
index cb92da20c..b4ec5fca2 100644
--- a/drizzle-orm/src/sql/sql.ts
+++ b/drizzle-orm/src/sql/sql.ts
@@ -582,3 +582,8 @@ export function fillPlaceholders(params: unknown[], values: Record<string, unkno
 Column.prototype.getSQL = function() {
 	return new SQL([this]);
 };
+
+// Defined separately from the Table class to resolve circular dependency
+Table.prototype.getSQL = function() {
+	return new SQL([this]);
+};
diff --git a/drizzle-orm/src/table.ts b/drizzle-orm/src/table.ts
index 5ba5bcddb..1ce1019a9 100644
--- a/drizzle-orm/src/table.ts
+++ b/drizzle-orm/src/table.ts
@@ -1,7 +1,7 @@
 import type { Column, GetColumnData } from './column.ts';
 import { entityKind } from './entity.ts';
 import type { OptionalKeyOnly, RequiredKeyOnly } from './operations.ts';
-import { SQL, type SQLWrapper } from './sql/sql.ts';
+import type { SQLWrapper } from './sql/sql.ts';
 import type { Simplify, Update } from './utils.ts';
 
 export interface TableConfig<TColumn extends Column = Column<any>> {
@@ -38,6 +38,13 @@ export const ExtraConfigBuilder = Symbol.for('drizzle:ExtraConfigBuilder');
 
 const IsDrizzleTable = Symbol.for('drizzle:IsDrizzleTable');
 
+export interface Table<
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	T extends TableConfig = TableConfig,
+> extends SQLWrapper {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
+
 export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
 	static readonly [entityKind]: string = 'Table';
 
@@ -102,10 +109,6 @@ export class Table<T extends TableConfig = TableConfig> implements SQLWrapper {
 		this[Schema] = schema;
 		this[BaseName] = baseName;
 	}
-
-	getSQL(): SQL<unknown> {
-		return new SQL([this]);
-	}
 }
 
 export function isTable(table: unknown): table is Table {

From 5d6a6f2a506978afa90ee53fe089c934f81cff07 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Fri, 13 Oct 2023 02:15:41 +0300
Subject: [PATCH 40/72] Fix tables list in "for ... of" clause in pg select

---
 drizzle-orm/src/pg-core/dialect.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 8f274d493..6f5305568 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -333,7 +333,14 @@ export class PgDialect {
 		if (lockingClause) {
 			const clauseSql = sql` for ${sql.raw(lockingClause.strength)}`;
 			if (lockingClause.config.of) {
-				clauseSql.append(sql` of ${lockingClause.config.of}`);
+				clauseSql.append(
+					sql` of ${
+						sql.join(
+							Array.isArray(lockingClause.config.of) ? lockingClause.config.of : [lockingClause.config.of],
+							sql`, `,
+						)
+					}`,
+				);
 			}
 			if (lockingClause.config.noWait) {
 				clauseSql.append(sql` no wait`);

From 0028fb929e0ad15d819865c1ea6732e93d39f139 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Fri, 13 Oct 2023 02:19:55 +0300
Subject: [PATCH 41/72] Fix tests

---
 integration-tests/tests/postgres.js.test.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/integration-tests/tests/postgres.js.test.ts b/integration-tests/tests/postgres.js.test.ts
index e95cc736d..a1f979f60 100644
--- a/integration-tests/tests/postgres.js.test.ts
+++ b/integration-tests/tests/postgres.js.test.ts
@@ -9,7 +9,6 @@ import {
 	arrayContains,
 	arrayOverlaps,
 	asc,
-	DrizzleError,
 	eq,
 	gt,
 	gte,
@@ -21,6 +20,7 @@ import {
 	type SQL,
 	sql,
 	type SQLWrapper,
+	TransactionRollbackError,
 } from 'drizzle-orm';
 import {
 	alias,
@@ -1905,7 +1905,7 @@ test.serial('transaction rollback', async (t) => {
 		await db.transaction(async (tx) => {
 			await tx.insert(users).values({ balance: 100 });
 			await tx.rollback();
-		}), new DrizzleError({ message: 'Rollback' }));
+		}), { instanceOf: TransactionRollbackError });
 
 	const result = await db.select().from(users);
 
@@ -1964,7 +1964,7 @@ test.serial('nested transaction rollback', async (t) => {
 			await tx.transaction(async (tx) => {
 				await tx.update(users).set({ balance: 200 });
 				await tx.rollback();
-			}), new DrizzleError({ message: 'Rollback' }));
+			}), { instanceOf: TransactionRollbackError });
 	});
 
 	const result = await db.select().from(users);

From 9b4304fb4d0bb9eb28bc8590439b874af702cd1f Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Fri, 13 Oct 2023 10:36:20 +0300
Subject: [PATCH 42/72] Upgrade to 0.29.0

---
 .../drizzle-orm/{0.28.7.md => 0.29.0.md}      | 26 ++++++++++++++++++-
 drizzle-orm/package.json                      |  2 +-
 2 files changed, 26 insertions(+), 2 deletions(-)
 rename changelogs/drizzle-orm/{0.28.7.md => 0.29.0.md} (64%)

diff --git a/changelogs/drizzle-orm/0.28.7.md b/changelogs/drizzle-orm/0.29.0.md
similarity index 64%
rename from changelogs/drizzle-orm/0.28.7.md
rename to changelogs/drizzle-orm/0.29.0.md
index 0d07ea00f..daa86e5db 100644
--- a/changelogs/drizzle-orm/0.28.7.md
+++ b/changelogs/drizzle-orm/0.29.0.md
@@ -1,5 +1,29 @@
 ## New Features
 
+### MySQL `unsigned` option for bigint
+
+You can now specify `bigint unsigned` type
+
+```ts
+const table = mysqlTable('table', {
+	id: bigint('id', { mode: 'number', unsigned: true }),
+});
+```
+
+### Improved query builder types
+
+Starting from `0.29.0` by default, as all the query builders in Drizzle try to conform to SQL as much as possible, you can only invoke most of the methods once. For example, in a SELECT statement there might only be one WHERE clause, so you can only invoke .where() once:
+
+```ts
+const query = db
+	.select()
+	.from(users)
+	.where(eq(users.id, 1))
+	.where(eq(users.name, 'John')); // ❌ Type error - where() can only be invoked once
+```
+
+### Possibility to specify name for primary keys and foreign keys
+
 ### 🎉 `D1` batch api support
 
 Reference: https://developers.cloudflare.com/d1/platform/client-api/#dbbatch
@@ -62,4 +86,4 @@ All possible builders that can be used inside `db.batch`:
 `db.insert()...`,
 ```
 
-More usage examples here: [integration-tests/tests/d1-batch.test.ts](https://github.com/drizzle-team/drizzle-orm/blob/beta/integration-tests/tests/d1-batch.test.ts) and in [docs](https://orm.drizzle.team/docs/batch-api)
\ No newline at end of file
+More usage examples here: [integration-tests/tests/d1-batch.test.ts](https://github.com/drizzle-team/drizzle-orm/blob/beta/integration-tests/tests/d1-batch.test.ts) and in [docs](https://orm.drizzle.team/docs/batch-api)
diff --git a/drizzle-orm/package.json b/drizzle-orm/package.json
index b66c79824..3a28b9df7 100644
--- a/drizzle-orm/package.json
+++ b/drizzle-orm/package.json
@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.28.7",
+  "version": "0.29.0",
   "description": "Drizzle ORM package for SQL databases",
   "type": "module",
   "scripts": {

From 574902b76b0da597d3f300bc0d465ec8bf24b2a3 Mon Sep 17 00:00:00 2001
From: Roman <nabukhotnyiroman@gmail.com>
Date: Fri, 13 Oct 2023 11:35:57 +0300
Subject: [PATCH 43/72] fix: Fix pg-proxy tests

---
 integration-tests/tests/pg-proxy.test.ts | 77 ++++++++++++++++++++----
 1 file changed, 64 insertions(+), 13 deletions(-)

diff --git a/integration-tests/tests/pg-proxy.test.ts b/integration-tests/tests/pg-proxy.test.ts
index 93c7e5932..8eab46897 100644
--- a/integration-tests/tests/pg-proxy.test.ts
+++ b/integration-tests/tests/pg-proxy.test.ts
@@ -1648,20 +1648,71 @@ test.serial('array types', async (t) => {
 test.serial('select for ...', (t) => {
 	const { db } = t.context;
 
-	const query = db
-		.select()
-		.from(users2Table)
-		.for('update')
-		.for('no key update', { of: users2Table })
-		.for('no key update', { of: users2Table, skipLocked: true })
-		.for('share', { of: users2Table, noWait: true })
-		.toSQL();
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update')
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update$/,
+		);
+	}
 
-	t.regex(
-		query.sql,
-		// eslint-disable-next-line unicorn/better-regex
-		/ for update for no key update of "users2" for no key update of "users2" skip locked for share of "users2" no wait$/,
-	);
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('update', { of: [users2Table, coursesTable] })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for update of "users2", "courses"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/for no key update of "users2"$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('no key update', { of: users2Table, skipLocked: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			/ for no key update of "users2" skip locked$/,
+		);
+	}
+
+	{
+		const query = db
+			.select()
+			.from(users2Table)
+			.for('share', { of: users2Table, noWait: true })
+			.toSQL();
+
+		t.regex(
+			query.sql,
+			// eslint-disable-next-line unicorn/better-regex
+			/for share of "users2" no wait$/,
+		);
+	}
 });
 
 test.serial('having', async (t) => {

From f0b735218bc551c13390ad77ecde268952f6dca1 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Fri, 13 Oct 2023 19:32:12 +0300
Subject: [PATCH 44/72] Fix type import side effects

---
 .eslintrc.yaml                                |  1 +
 drizzle-orm/src/aws-data-api/pg/driver.ts     |  2 +-
 drizzle-orm/src/aws-data-api/pg/session.ts    |  2 +-
 drizzle-orm/src/better-sqlite3/driver.ts      |  2 +-
 drizzle-orm/src/better-sqlite3/session.ts     |  2 +-
 drizzle-orm/src/bun-sqlite/driver.ts          |  2 +-
 drizzle-orm/src/bun-sqlite/session.ts         |  2 +-
 drizzle-orm/src/d1/driver.ts                  |  2 +-
 drizzle-orm/src/d1/session.ts                 | 10 ++++-----
 drizzle-orm/src/libsql/driver.ts              |  2 +-
 drizzle-orm/src/libsql/session.ts             | 12 +++++-----
 drizzle-orm/src/mysql-core/alias.ts           |  2 +-
 drizzle-orm/src/mysql-core/columns/char.ts    |  2 +-
 drizzle-orm/src/mysql-core/columns/common.ts  |  2 +-
 drizzle-orm/src/mysql-core/columns/custom.ts  |  2 +-
 drizzle-orm/src/mysql-core/columns/date.ts    |  2 +-
 .../src/mysql-core/columns/datetime.ts        |  2 +-
 drizzle-orm/src/mysql-core/columns/enum.ts    |  2 +-
 drizzle-orm/src/mysql-core/columns/text.ts    |  2 +-
 .../src/mysql-core/columns/timestamp.ts       |  2 +-
 drizzle-orm/src/mysql-core/columns/varchar.ts |  2 +-
 drizzle-orm/src/mysql-core/db.ts              | 12 +++++-----
 .../query-builders/query-builder.ts           |  2 +-
 drizzle-orm/src/mysql-core/session.ts         |  4 ++--
 drizzle-orm/src/mysql-core/subquery.ts        |  2 +-
 drizzle-orm/src/mysql-core/view.ts            |  2 +-
 drizzle-orm/src/mysql-proxy/driver.ts         |  2 +-
 drizzle-orm/src/mysql-proxy/session.ts        | 10 ++++-----
 drizzle-orm/src/mysql2/driver.ts              |  4 ++--
 drizzle-orm/src/mysql2/session.ts             | 22 +++++++++----------
 drizzle-orm/src/neon-http/driver.ts           |  2 +-
 drizzle-orm/src/neon-http/migrator.ts         |  2 +-
 drizzle-orm/src/neon-http/session.ts          |  4 ++--
 drizzle-orm/src/neon-serverless/driver.ts     |  2 +-
 drizzle-orm/src/neon-serverless/session.ts    |  2 +-
 drizzle-orm/src/node-postgres/driver.ts       |  2 +-
 drizzle-orm/src/node-postgres/session.ts      |  2 +-
 drizzle-orm/src/pg-core/alias.ts              |  2 +-
 drizzle-orm/src/pg-core/columns/char.ts       |  2 +-
 drizzle-orm/src/pg-core/columns/custom.ts     |  2 +-
 drizzle-orm/src/pg-core/columns/enum.ts       |  2 +-
 drizzle-orm/src/pg-core/columns/text.ts       |  2 +-
 drizzle-orm/src/pg-core/columns/timestamp.ts  |  2 +-
 drizzle-orm/src/pg-core/columns/varchar.ts    |  2 +-
 drizzle-orm/src/pg-core/db.ts                 | 18 +++++++--------
 .../pg-core/query-builders/query-builder.ts   |  6 ++---
 .../src/pg-core/query-builders/query.ts       |  4 ++--
 drizzle-orm/src/pg-core/session.ts            |  2 +-
 drizzle-orm/src/pg-core/subquery.ts           |  2 +-
 drizzle-orm/src/pg-proxy/driver.ts            |  2 +-
 drizzle-orm/src/pg-proxy/session.ts           |  4 ++--
 .../src/planetscale-serverless/driver.ts      |  2 +-
 .../src/planetscale-serverless/session.ts     |  2 +-
 drizzle-orm/src/postgres-js/driver.ts         |  2 +-
 drizzle-orm/src/postgres-js/session.ts        |  2 +-
 drizzle-orm/src/primary-key.ts                |  4 ++--
 drizzle-orm/src/relations.ts                  |  2 +-
 drizzle-orm/src/sql-js/driver.ts              |  2 +-
 drizzle-orm/src/sql-js/session.ts             |  2 +-
 drizzle-orm/src/sqlite-core/alias.ts          |  6 ++---
 drizzle-orm/src/sqlite-core/columns/blob.ts   |  2 +-
 drizzle-orm/src/sqlite-core/columns/common.ts |  2 +-
 drizzle-orm/src/sqlite-core/columns/custom.ts |  2 +-
 .../src/sqlite-core/columns/integer.ts        |  2 +-
 drizzle-orm/src/sqlite-core/columns/text.ts   |  2 +-
 drizzle-orm/src/sqlite-core/db.ts             | 12 +++++-----
 drizzle-orm/src/sqlite-core/indexes.ts        |  2 +-
 .../src/sqlite-core/query-builders/query.ts   |  8 +++----
 .../query-builders/select.types.ts            |  2 +-
 drizzle-orm/src/sqlite-core/session.ts        |  2 +-
 drizzle-orm/src/sqlite-core/subquery.ts       |  2 +-
 drizzle-orm/src/sqlite-proxy/driver.ts        |  2 +-
 drizzle-orm/src/utils.ts                      |  4 ++--
 drizzle-orm/src/vercel-postgres/driver.ts     |  2 +-
 drizzle-orm/src/vercel-postgres/session.ts    |  2 +-
 drizzle-orm/type-tests/mysql/tables.ts        |  2 +-
 drizzle-orm/type-tests/pg/array.ts            |  2 +-
 drizzle-orm/type-tests/sqlite/delete.ts       |  2 +-
 drizzle-orm/type-tests/sqlite/insert.ts       |  2 +-
 drizzle-orm/type-tests/sqlite/update.ts       |  2 +-
 drizzle-valibot/tests/utils.ts                |  2 +-
 81 files changed, 136 insertions(+), 135 deletions(-)

diff --git a/.eslintrc.yaml b/.eslintrc.yaml
index 5c26b2a2b..bc71e00bc 100644
--- a/.eslintrc.yaml
+++ b/.eslintrc.yaml
@@ -16,6 +16,7 @@ rules:
     - error
     - disallowTypeAnnotations: false
       fixStyle: separate-type-imports
+  '@typescript-eslint/no-import-type-side-effects': 'error'
   import/no-cycle: error
   import/no-self-import: error
   import/no-empty-named-blocks: error
diff --git a/drizzle-orm/src/aws-data-api/pg/driver.ts b/drizzle-orm/src/aws-data-api/pg/driver.ts
index dac77b54d..e5acbe939 100644
--- a/drizzle-orm/src/aws-data-api/pg/driver.ts
+++ b/drizzle-orm/src/aws-data-api/pg/driver.ts
@@ -9,7 +9,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import type { AwsDataApiClient, AwsDataApiPgQueryResultHKT } from './session.ts';
 import { AwsDataApiSession } from './session.ts';
 
diff --git a/drizzle-orm/src/aws-data-api/pg/session.ts b/drizzle-orm/src/aws-data-api/pg/session.ts
index ebfd9ece1..f52f4d0b3 100644
--- a/drizzle-orm/src/aws-data-api/pg/session.ts
+++ b/drizzle-orm/src/aws-data-api/pg/session.ts
@@ -17,7 +17,7 @@ import {
 	type QueryResultHKT,
 } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type QueryTypingsValue, type QueryWithTypings, type SQL, sql } from '~/sql/index.ts';
 import { mapResultRow } from '~/utils.ts';
 import { getValueFromDataApi, toValueParam } from '../common/index.ts';
diff --git a/drizzle-orm/src/better-sqlite3/driver.ts b/drizzle-orm/src/better-sqlite3/driver.ts
index ac2c7db0a..728586e57 100644
--- a/drizzle-orm/src/better-sqlite3/driver.ts
+++ b/drizzle-orm/src/better-sqlite3/driver.ts
@@ -8,7 +8,7 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { BetterSQLiteSession } from './session.ts';
 
 export type BetterSQLite3Database<
diff --git a/drizzle-orm/src/better-sqlite3/session.ts b/drizzle-orm/src/better-sqlite3/session.ts
index a93ea74c8..64cf7b9dd 100644
--- a/drizzle-orm/src/better-sqlite3/session.ts
+++ b/drizzle-orm/src/better-sqlite3/session.ts
@@ -2,7 +2,7 @@ import type { Database, RunResult, Statement } from 'better-sqlite3';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
diff --git a/drizzle-orm/src/bun-sqlite/driver.ts b/drizzle-orm/src/bun-sqlite/driver.ts
index 36d500748..0d196ff03 100644
--- a/drizzle-orm/src/bun-sqlite/driver.ts
+++ b/drizzle-orm/src/bun-sqlite/driver.ts
@@ -10,7 +10,7 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { SQLiteBunSession } from './session.ts';
 
 export type BunSQLiteDatabase<
diff --git a/drizzle-orm/src/bun-sqlite/session.ts b/drizzle-orm/src/bun-sqlite/session.ts
index 009663123..3f8ac11de 100644
--- a/drizzle-orm/src/bun-sqlite/session.ts
+++ b/drizzle-orm/src/bun-sqlite/session.ts
@@ -4,7 +4,7 @@ import type { Database, Statement as BunStatement } from 'bun:sqlite';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
diff --git a/drizzle-orm/src/d1/driver.ts b/drizzle-orm/src/d1/driver.ts
index 628ada725..0cbd0a0cc 100644
--- a/drizzle-orm/src/d1/driver.ts
+++ b/drizzle-orm/src/d1/driver.ts
@@ -11,7 +11,7 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { SQLiteD1Session } from './session.ts';
 
 export class DrizzleD1Database<
diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index aee75abf5..1de446f2c 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -4,17 +4,17 @@ import type { BatchItem } from '~/batch.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import type { PreparedQuery } from '~/session.ts';
 import { type Query, sql } from '~/sql/index.ts';
 import { fillPlaceholders } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
-import {
-	type PreparedQueryConfig as PreparedQueryConfigBase,
-	type SQLiteExecuteMethod,
-	type SQLiteTransactionConfig,
+import type {
+	PreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteExecuteMethod,
+	SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
 import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
diff --git a/drizzle-orm/src/libsql/driver.ts b/drizzle-orm/src/libsql/driver.ts
index fc3d41ca7..3acff2893 100644
--- a/drizzle-orm/src/libsql/driver.ts
+++ b/drizzle-orm/src/libsql/driver.ts
@@ -11,7 +11,7 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { LibSQLSession } from './session.ts';
 
 export class LibSQLDatabase<
diff --git a/drizzle-orm/src/libsql/session.ts b/drizzle-orm/src/libsql/session.ts
index bd6658943..e8fb7e24a 100644
--- a/drizzle-orm/src/libsql/session.ts
+++ b/drizzle-orm/src/libsql/session.ts
@@ -1,18 +1,18 @@
-import { type Client, type InArgs, type InStatement, type ResultSet, type Transaction } from '@libsql/client';
+import type { Client, InArgs, InStatement, ResultSet, Transaction } from '@libsql/client';
 import type { BatchItem as BatchItem } from '~/batch.ts';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import type { PreparedQuery } from '~/session.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
-import {
-	type PreparedQueryConfig as PreparedQueryConfigBase,
-	type SQLiteExecuteMethod,
-	type SQLiteTransactionConfig,
+import type {
+	PreparedQueryConfig as PreparedQueryConfigBase,
+	SQLiteExecuteMethod,
+	SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
 import { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { mapResultRow } from '~/utils.ts';
diff --git a/drizzle-orm/src/mysql-core/alias.ts b/drizzle-orm/src/mysql-core/alias.ts
index 08d70f035..59ab93dbb 100644
--- a/drizzle-orm/src/mysql-core/alias.ts
+++ b/drizzle-orm/src/mysql-core/alias.ts
@@ -1,7 +1,7 @@
 import { TableAliasProxyHandler } from '~/alias.ts';
 import type { BuildAliasTable } from './query-builders/select.types.ts';
 import type { MySqlTable } from './table.ts';
-import { type MySqlViewBase } from './view.ts';
+import type { MySqlViewBase } from './view.ts';
 
 export function alias<TTable extends MySqlTable | MySqlViewBase, TAlias extends string>(
 	table: TTable,
diff --git a/drizzle-orm/src/mysql-core/columns/char.ts b/drizzle-orm/src/mysql-core/columns/char.ts
index 78b845e71..5466ec046 100644
--- a/drizzle-orm/src/mysql-core/columns/char.ts
+++ b/drizzle-orm/src/mysql-core/columns/char.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export type MySqlCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = MySqlCharBuilder<{
diff --git a/drizzle-orm/src/mysql-core/columns/common.ts b/drizzle-orm/src/mysql-core/columns/common.ts
index 2f1ee2fce..fe518cebb 100644
--- a/drizzle-orm/src/mysql-core/columns/common.ts
+++ b/drizzle-orm/src/mysql-core/columns/common.ts
@@ -14,7 +14,7 @@ import { entityKind } from '~/entity.ts';
 import type { ForeignKey, UpdateDeleteAction } from '~/mysql-core/foreign-keys.ts';
 import { ForeignKeyBuilder } from '~/mysql-core/foreign-keys.ts';
 import type { AnyMySqlTable, MySqlTable } from '~/mysql-core/table.ts';
-import { type Update } from '~/utils.ts';
+import type { Update } from '~/utils.ts';
 import { uniqueKeyName } from '../unique-constraint.ts';
 
 export interface ReferenceConfig {
diff --git a/drizzle-orm/src/mysql-core/columns/custom.ts b/drizzle-orm/src/mysql-core/columns/custom.ts
index c67904e38..02d7b9c68 100644
--- a/drizzle-orm/src/mysql-core/columns/custom.ts
+++ b/drizzle-orm/src/mysql-core/columns/custom.ts
@@ -3,7 +3,7 @@ import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
 import type { SQL } from '~/sql/index.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
diff --git a/drizzle-orm/src/mysql-core/columns/date.ts b/drizzle-orm/src/mysql-core/columns/date.ts
index 396e23d60..c51971829 100644
--- a/drizzle-orm/src/mysql-core/columns/date.ts
+++ b/drizzle-orm/src/mysql-core/columns/date.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export type MySqlDateBuilderInitial<TName extends string> = MySqlDateBuilder<{
diff --git a/drizzle-orm/src/mysql-core/columns/datetime.ts b/drizzle-orm/src/mysql-core/columns/datetime.ts
index 97b364b37..cfe9ce0b7 100644
--- a/drizzle-orm/src/mysql-core/columns/datetime.ts
+++ b/drizzle-orm/src/mysql-core/columns/datetime.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export type MySqlDateTimeBuilderInitial<TName extends string> = MySqlDateTimeBuilder<{
diff --git a/drizzle-orm/src/mysql-core/columns/enum.ts b/drizzle-orm/src/mysql-core/columns/enum.ts
index 48221f868..a7d5399ed 100644
--- a/drizzle-orm/src/mysql-core/columns/enum.ts
+++ b/drizzle-orm/src/mysql-core/columns/enum.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export type MySqlEnumColumnBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
diff --git a/drizzle-orm/src/mysql-core/columns/text.ts b/drizzle-orm/src/mysql-core/columns/text.ts
index 9853532d4..8a4a30822 100644
--- a/drizzle-orm/src/mysql-core/columns/text.ts
+++ b/drizzle-orm/src/mysql-core/columns/text.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export type MySqlTextColumnType = 'tinytext' | 'text' | 'mediumtext' | 'longtext';
diff --git a/drizzle-orm/src/mysql-core/columns/timestamp.ts b/drizzle-orm/src/mysql-core/columns/timestamp.ts
index aed1ad04a..3b6df80d3 100644
--- a/drizzle-orm/src/mysql-core/columns/timestamp.ts
+++ b/drizzle-orm/src/mysql-core/columns/timestamp.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { MySqlDateBaseColumn, MySqlDateColumnBaseBuilder } from './date.common.ts';
 
 export type MySqlTimestampBuilderInitial<TName extends string> = MySqlTimestampBuilder<{
diff --git a/drizzle-orm/src/mysql-core/columns/varchar.ts b/drizzle-orm/src/mysql-core/columns/varchar.ts
index 99c52db77..7db55563f 100644
--- a/drizzle-orm/src/mysql-core/columns/varchar.ts
+++ b/drizzle-orm/src/mysql-core/columns/varchar.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export type MySqlVarCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = MySqlVarCharBuilder<
diff --git a/drizzle-orm/src/mysql-core/db.ts b/drizzle-orm/src/mysql-core/db.ts
index 6e3a1e523..11ee57fcd 100644
--- a/drizzle-orm/src/mysql-core/db.ts
+++ b/drizzle-orm/src/mysql-core/db.ts
@@ -1,15 +1,15 @@
 import type { ResultSetHeader } from 'mysql2/promise';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import {
-	type ExtractTablesWithRelations,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
+import type {
+	ExtractTablesWithRelations,
+	RelationalSchemaConfig,
+	TablesRelationalConfig,
 } from '~/relations.ts';
 import type { SQLWrapper } from '~/sql/index.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import { type DrizzleTypeError } from '~/utils.ts';
-import { type ColumnsSelection } from '~/view.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
+import type { ColumnsSelection } from '~/view.ts';
 import type { MySqlDialect } from './dialect.ts';
 import {
 	MySqlDeleteBase,
diff --git a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
index 565105207..a145f65b3 100644
--- a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
@@ -3,7 +3,7 @@ import { MySqlDialect } from '~/mysql-core/dialect.ts';
 import type { WithSubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import { type ColumnsSelection } from '~/view.ts';
+import type { ColumnsSelection } from '~/view.ts';
 import { MySqlSelectBuilder } from './select.ts';
 import type { SelectedFields } from './select.types.ts';
 
diff --git a/drizzle-orm/src/mysql-core/session.ts b/drizzle-orm/src/mysql-core/session.ts
index c4346fa54..82320e0e1 100644
--- a/drizzle-orm/src/mysql-core/session.ts
+++ b/drizzle-orm/src/mysql-core/session.ts
@@ -1,8 +1,8 @@
 import { entityKind } from '~/entity.ts';
 import { TransactionRollbackError } from '~/errors.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { type Query, type SQL, sql } from '~/sql/index.ts';
-import { type Assume, type Equal } from '~/utils.ts';
+import type { Assume, Equal } from '~/utils.ts';
 import { MySqlDatabase } from './db.ts';
 import type { MySqlDialect } from './dialect.ts';
 import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
diff --git a/drizzle-orm/src/mysql-core/subquery.ts b/drizzle-orm/src/mysql-core/subquery.ts
index 90f7736a6..3a7378ba2 100644
--- a/drizzle-orm/src/mysql-core/subquery.ts
+++ b/drizzle-orm/src/mysql-core/subquery.ts
@@ -1,6 +1,6 @@
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import type { Subquery, WithSubquery } from '~/subquery.ts';
-import { type ColumnsSelection } from '~/view.ts';
+import type { ColumnsSelection } from '~/view.ts';
 
 export type SubqueryWithSelection<
 	TSelection extends ColumnsSelection,
diff --git a/drizzle-orm/src/mysql-core/view.ts b/drizzle-orm/src/mysql-core/view.ts
index 4d0dd216f..fda47b231 100644
--- a/drizzle-orm/src/mysql-core/view.ts
+++ b/drizzle-orm/src/mysql-core/view.ts
@@ -6,7 +6,7 @@ import type { SQL } from '~/sql/index.ts';
 import { SelectionProxyHandler } from '~/subquery.ts';
 import { getTableColumns } from '~/utils.ts';
 import { type ColumnsSelection, View } from '~/view.ts';
-import { type MySqlColumn, type MySqlColumnBuilderBase } from './columns/index.ts';
+import type { MySqlColumn, MySqlColumnBuilderBase } from './columns/index.ts';
 import { QueryBuilder } from './query-builders/index.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { mysqlTable } from './table.ts';
diff --git a/drizzle-orm/src/mysql-proxy/driver.ts b/drizzle-orm/src/mysql-proxy/driver.ts
index f807f6c56..13a289306 100644
--- a/drizzle-orm/src/mysql-proxy/driver.ts
+++ b/drizzle-orm/src/mysql-proxy/driver.ts
@@ -7,7 +7,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { MySqlRemoteSession, type MySqlRemoteQueryResultHKT, type MySqlRemotePreparedQueryHKT } from './session.ts';
 
 export type MySqlRemoteDatabase<
diff --git a/drizzle-orm/src/mysql-proxy/session.ts b/drizzle-orm/src/mysql-proxy/session.ts
index e9d660d4d..fd57015eb 100644
--- a/drizzle-orm/src/mysql-proxy/session.ts
+++ b/drizzle-orm/src/mysql-proxy/session.ts
@@ -4,16 +4,16 @@ import { NoopLogger } from '~/logger.ts';
 import { MySqlTransaction } from '~/mysql-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/mysql-core/query-builders/select.types.ts';
 import type { MySqlTransactionConfig, QueryResultHKT , PreparedQueryConfig, PreparedQueryHKT, PreparedQueryKind } from '~/mysql-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders} from '~/sql/index.ts';
 import type { SQL, Query } from '~/sql/index.ts';
 import { mapResultRow, type Assume } from '~/utils.ts';
-import { type RemoteCallback } from './driver.ts';
+import type { RemoteCallback } from './driver.ts';
 import { MySqlSession, PreparedQuery as PreparedQueryBase } from '~/mysql-core/session.ts';
 import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import {
-	type FieldPacket,
-	type ResultSetHeader,
+import type {
+	FieldPacket,
+	ResultSetHeader,
 } from 'mysql2/promise';
 
 export type MySqlRawQueryResult = [ResultSetHeader, FieldPacket[]];
diff --git a/drizzle-orm/src/mysql2/driver.ts b/drizzle-orm/src/mysql2/driver.ts
index cb0561ee2..3b21bf11d 100644
--- a/drizzle-orm/src/mysql2/driver.ts
+++ b/drizzle-orm/src/mysql2/driver.ts
@@ -1,4 +1,4 @@
-import { type Connection as CallbackConnection, type Pool as CallbackPool } from 'mysql2';
+import type { Connection as CallbackConnection, Pool as CallbackPool } from 'mysql2';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
@@ -11,7 +11,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { DrizzleError } from '../index.ts';
 import type { MySql2Client, MySql2PreparedQueryHKT, MySql2QueryResultHKT } from './session.ts';
 import { MySql2Session } from './session.ts';
diff --git a/drizzle-orm/src/mysql2/session.ts b/drizzle-orm/src/mysql2/session.ts
index 31b86a56d..13e25c812 100644
--- a/drizzle-orm/src/mysql2/session.ts
+++ b/drizzle-orm/src/mysql2/session.ts
@@ -1,13 +1,13 @@
-import { type Connection as CallbackConnection } from 'mysql2';
-import {
-	type Connection,
-	type FieldPacket,
-	type OkPacket,
-	type Pool,
-	type PoolConnection,
-	type QueryOptions,
-	type ResultSetHeader,
-	type RowDataPacket,
+import type { Connection as CallbackConnection } from 'mysql2';
+import type {
+	Connection,
+	FieldPacket,
+	OkPacket,
+	Pool,
+	PoolConnection,
+	QueryOptions,
+	ResultSetHeader,
+	RowDataPacket,
 } from 'mysql2/promise';
 import { once } from 'node:events';
 import { entityKind } from '~/entity.ts';
@@ -26,7 +26,7 @@ import {
 	type PreparedQueryKind,
 	type QueryResultHKT,
 } from '~/mysql-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/index.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
diff --git a/drizzle-orm/src/neon-http/driver.ts b/drizzle-orm/src/neon-http/driver.ts
index 9681299ce..7172dfd01 100644
--- a/drizzle-orm/src/neon-http/driver.ts
+++ b/drizzle-orm/src/neon-http/driver.ts
@@ -10,7 +10,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { type NeonHttpClient, type NeonHttpQueryResultHKT, NeonHttpSession } from './session.ts';
 
 export interface NeonDriverOptions {
diff --git a/drizzle-orm/src/neon-http/migrator.ts b/drizzle-orm/src/neon-http/migrator.ts
index b56d5f7d6..e4b00d27a 100644
--- a/drizzle-orm/src/neon-http/migrator.ts
+++ b/drizzle-orm/src/neon-http/migrator.ts
@@ -1,7 +1,7 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
 import { type SQL, sql } from '~/sql/index.ts';
-import { type NeonHttpDatabase } from './driver.ts';
+import type { NeonHttpDatabase } from './driver.ts';
 
 /**
  * This function reads migrationFolder and execute each unapplied migration and mark it as executed in database
diff --git a/drizzle-orm/src/neon-http/session.ts b/drizzle-orm/src/neon-http/session.ts
index e12cb014c..9609412e4 100644
--- a/drizzle-orm/src/neon-http/session.ts
+++ b/drizzle-orm/src/neon-http/session.ts
@@ -1,4 +1,4 @@
-import { type FullQueryResults, type QueryRows } from '@neondatabase/serverless';
+import type { FullQueryResults, QueryRows } from '@neondatabase/serverless';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
@@ -7,7 +7,7 @@ import { PgTransaction } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query } from '~/sql/index.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
diff --git a/drizzle-orm/src/neon-serverless/driver.ts b/drizzle-orm/src/neon-serverless/driver.ts
index a90213d56..9f58b0e65 100644
--- a/drizzle-orm/src/neon-serverless/driver.ts
+++ b/drizzle-orm/src/neon-serverless/driver.ts
@@ -10,7 +10,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import type { NeonClient, NeonQueryResultHKT } from './session.ts';
 import { NeonSession } from './session.ts';
 
diff --git a/drizzle-orm/src/neon-serverless/session.ts b/drizzle-orm/src/neon-serverless/session.ts
index 7e47bc093..c49319bb4 100644
--- a/drizzle-orm/src/neon-serverless/session.ts
+++ b/drizzle-orm/src/neon-serverless/session.ts
@@ -15,7 +15,7 @@ import { PgTransaction } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
diff --git a/drizzle-orm/src/node-postgres/driver.ts b/drizzle-orm/src/node-postgres/driver.ts
index 5ad20ce23..4c233f891 100644
--- a/drizzle-orm/src/node-postgres/driver.ts
+++ b/drizzle-orm/src/node-postgres/driver.ts
@@ -10,7 +10,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import type { NodePgClient, NodePgQueryResultHKT } from './session.ts';
 import { NodePgSession } from './session.ts';
 
diff --git a/drizzle-orm/src/node-postgres/session.ts b/drizzle-orm/src/node-postgres/session.ts
index eac168c7e..6167ee16b 100644
--- a/drizzle-orm/src/node-postgres/session.ts
+++ b/drizzle-orm/src/node-postgres/session.ts
@@ -7,7 +7,7 @@ import { PgTransaction } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import { tracer } from '~/tracing.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
diff --git a/drizzle-orm/src/pg-core/alias.ts b/drizzle-orm/src/pg-core/alias.ts
index 2d9800e7e..89e8255c1 100644
--- a/drizzle-orm/src/pg-core/alias.ts
+++ b/drizzle-orm/src/pg-core/alias.ts
@@ -2,7 +2,7 @@ import { TableAliasProxyHandler } from '~/alias.ts';
 import type { BuildAliasTable } from './query-builders/select.types.ts';
 
 import type { PgTable } from './table.ts';
-import { type PgViewBase } from './view.ts';
+import type { PgViewBase } from './view.ts';
 
 export function alias<TTable extends PgTable | PgViewBase, TAlias extends string>(
 	table: TTable,
diff --git a/drizzle-orm/src/pg-core/columns/char.ts b/drizzle-orm/src/pg-core/columns/char.ts
index 1c5d88416..85eb65954 100644
--- a/drizzle-orm/src/pg-core/columns/char.ts
+++ b/drizzle-orm/src/pg-core/columns/char.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 export type PgCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgCharBuilder<{
diff --git a/drizzle-orm/src/pg-core/columns/custom.ts b/drizzle-orm/src/pg-core/columns/custom.ts
index ff768d0ae..43492669a 100644
--- a/drizzle-orm/src/pg-core/columns/custom.ts
+++ b/drizzle-orm/src/pg-core/columns/custom.ts
@@ -3,7 +3,7 @@ import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
 import type { SQL } from '~/sql/index.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
diff --git a/drizzle-orm/src/pg-core/columns/enum.ts b/drizzle-orm/src/pg-core/columns/enum.ts
index dcae97545..7f3840271 100644
--- a/drizzle-orm/src/pg-core/columns/enum.ts
+++ b/drizzle-orm/src/pg-core/columns/enum.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 export type PgEnumColumnBuilderInitial<TName extends string, TValues extends [string, ...string[]]> =
diff --git a/drizzle-orm/src/pg-core/columns/text.ts b/drizzle-orm/src/pg-core/columns/text.ts
index 946d5f3cb..844e9182c 100644
--- a/drizzle-orm/src/pg-core/columns/text.ts
+++ b/drizzle-orm/src/pg-core/columns/text.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 type PgTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgTextBuilder<{
diff --git a/drizzle-orm/src/pg-core/columns/timestamp.ts b/drizzle-orm/src/pg-core/columns/timestamp.ts
index 92a2f4be1..3060bfb3f 100644
--- a/drizzle-orm/src/pg-core/columns/timestamp.ts
+++ b/drizzle-orm/src/pg-core/columns/timestamp.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { PgColumn } from './common.ts';
 import { PgDateColumnBaseBuilder } from './date.common.ts';
 
diff --git a/drizzle-orm/src/pg-core/columns/varchar.ts b/drizzle-orm/src/pg-core/columns/varchar.ts
index 488a605b8..31d66aade 100644
--- a/drizzle-orm/src/pg-core/columns/varchar.ts
+++ b/drizzle-orm/src/pg-core/columns/varchar.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import { type Writable } from '~/utils.ts';
+import type { Writable } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 export type PgVarcharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgVarcharBuilder<{
diff --git a/drizzle-orm/src/pg-core/db.ts b/drizzle-orm/src/pg-core/db.ts
index ebe919337..df6bfb6a7 100644
--- a/drizzle-orm/src/pg-core/db.ts
+++ b/drizzle-orm/src/pg-core/db.ts
@@ -14,18 +14,18 @@ import type {
 	QueryResultHKT,
 	QueryResultKind,
 } from '~/pg-core/session.ts';
-import { type PgTable } from '~/pg-core/table.ts';
+import type { PgTable } from '~/pg-core/table.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import {
-	type ExtractTablesWithRelations,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
+import type {
+	ExtractTablesWithRelations,
+	RelationalSchemaConfig,
+	TablesRelationalConfig,
 } from '~/relations.ts';
-import { type SQLWrapper } from '~/sql/index.ts';
+import type { SQLWrapper } from '~/sql/index.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import { type DrizzleTypeError } from '~/utils.ts';
-import { type ColumnsSelection } from '~/view.ts';
-import { type PgColumn } from './columns/index.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
+import type { ColumnsSelection } from '~/view.ts';
+import type { PgColumn } from './columns/index.ts';
 import { RelationalQueryBuilder } from './query-builders/query.ts';
 import { PgRefreshMaterializedView } from './query-builders/refresh-materialized-view.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/query-builder.ts b/drizzle-orm/src/pg-core/query-builders/query-builder.ts
index d0b6590c1..f1d208574 100644
--- a/drizzle-orm/src/pg-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/pg-core/query-builders/query-builder.ts
@@ -1,10 +1,10 @@
 import { entityKind } from '~/entity.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import { type SQLWrapper } from '~/sql/index.ts';
+import type { SQLWrapper } from '~/sql/index.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import { type ColumnsSelection } from '~/view.ts';
-import { type PgColumn } from '../columns/index.ts';
+import type { ColumnsSelection } from '~/view.ts';
+import type { PgColumn } from '../columns/index.ts';
 import type { WithSubqueryWithSelection } from '../subquery.ts';
 import { PgSelectBuilder } from './select.ts';
 import type { SelectedFields } from './select.types.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/query.ts b/drizzle-orm/src/pg-core/query-builders/query.ts
index 8c7cdc88e..70272f982 100644
--- a/drizzle-orm/src/pg-core/query-builders/query.ts
+++ b/drizzle-orm/src/pg-core/query-builders/query.ts
@@ -10,10 +10,10 @@ import {
 } from '~/relations.ts';
 import type { Query, QueryWithTypings, SQL } from '~/sql/index.ts';
 import { tracer } from '~/tracing.ts';
-import { type KnownKeysOnly } from '~/utils.ts';
+import type { KnownKeysOnly } from '~/utils.ts';
 import type { PgDialect } from '../dialect.ts';
 import type { PgSession, PreparedQuery, PreparedQueryConfig } from '../session.ts';
-import { type PgTable } from '../table.ts';
+import type { PgTable } from '../table.ts';
 
 export class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
 	static readonly [entityKind]: string = 'PgRelationalQueryBuilder';
diff --git a/drizzle-orm/src/pg-core/session.ts b/drizzle-orm/src/pg-core/session.ts
index 87dbdc76d..2b65567c6 100644
--- a/drizzle-orm/src/pg-core/session.ts
+++ b/drizzle-orm/src/pg-core/session.ts
@@ -1,6 +1,6 @@
 import { entityKind } from '~/entity.ts';
 import { TransactionRollbackError } from '~/errors.ts';
-import { type TablesRelationalConfig } from '~/relations.ts';
+import type { TablesRelationalConfig } from '~/relations.ts';
 import { type Query, type SQL, sql } from '~/sql/index.ts';
 import { tracer } from '~/tracing.ts';
 import { PgDatabase } from './db.ts';
diff --git a/drizzle-orm/src/pg-core/subquery.ts b/drizzle-orm/src/pg-core/subquery.ts
index f2952628c..fefb08cac 100644
--- a/drizzle-orm/src/pg-core/subquery.ts
+++ b/drizzle-orm/src/pg-core/subquery.ts
@@ -1,6 +1,6 @@
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import type { Subquery, WithSubquery } from '~/subquery.ts';
-import { type ColumnsSelection } from '~/view.ts';
+import type { ColumnsSelection } from '~/view.ts';
 
 export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
 	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>>
diff --git a/drizzle-orm/src/pg-proxy/driver.ts b/drizzle-orm/src/pg-proxy/driver.ts
index 76ae60b0a..2b331d0eb 100644
--- a/drizzle-orm/src/pg-proxy/driver.ts
+++ b/drizzle-orm/src/pg-proxy/driver.ts
@@ -7,7 +7,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { PgRemoteSession, type PgRemoteQueryResultHKT } from './session.ts';
 
 export type PgRemoteDatabase<
diff --git a/drizzle-orm/src/pg-proxy/session.ts b/drizzle-orm/src/pg-proxy/session.ts
index ce9f545aa..8461df9aa 100644
--- a/drizzle-orm/src/pg-proxy/session.ts
+++ b/drizzle-orm/src/pg-proxy/session.ts
@@ -6,11 +6,11 @@ import { PgTransaction } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery as PreparedQueryBase } from '~/pg-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query } from '~/sql/index.ts';
 import { tracer } from '~/tracing.ts';
 import { mapResultRow, type Assume } from '~/utils.ts';
-import { type RemoteCallback } from './driver.ts';
+import type { RemoteCallback } from './driver.ts';
 
 export interface PgRemoteSessionOptions {
 	logger?: Logger;
diff --git a/drizzle-orm/src/planetscale-serverless/driver.ts b/drizzle-orm/src/planetscale-serverless/driver.ts
index 9f55a2fac..2cc72053f 100644
--- a/drizzle-orm/src/planetscale-serverless/driver.ts
+++ b/drizzle-orm/src/planetscale-serverless/driver.ts
@@ -9,7 +9,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import type { PlanetScalePreparedQueryHKT, PlanetscaleQueryResultHKT } from './session.ts';
 import { PlanetscaleSession } from './session.ts';
 
diff --git a/drizzle-orm/src/planetscale-serverless/session.ts b/drizzle-orm/src/planetscale-serverless/session.ts
index 8652120ff..2f235af41 100644
--- a/drizzle-orm/src/planetscale-serverless/session.ts
+++ b/drizzle-orm/src/planetscale-serverless/session.ts
@@ -12,7 +12,7 @@ import {
 	type PreparedQueryHKT,
 	type QueryResultHKT,
 } from '~/mysql-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/index.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
diff --git a/drizzle-orm/src/postgres-js/driver.ts b/drizzle-orm/src/postgres-js/driver.ts
index bdc2a958d..9726bef8f 100644
--- a/drizzle-orm/src/postgres-js/driver.ts
+++ b/drizzle-orm/src/postgres-js/driver.ts
@@ -8,7 +8,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import type { PostgresJsQueryResultHKT } from './session.ts';
 import { PostgresJsSession } from './session.ts';
 
diff --git a/drizzle-orm/src/postgres-js/session.ts b/drizzle-orm/src/postgres-js/session.ts
index 8431ca2e0..a430f2415 100644
--- a/drizzle-orm/src/postgres-js/session.ts
+++ b/drizzle-orm/src/postgres-js/session.ts
@@ -7,7 +7,7 @@ import { PgTransaction } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query } from '~/sql/index.ts';
 import { tracer } from '~/tracing.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
diff --git a/drizzle-orm/src/primary-key.ts b/drizzle-orm/src/primary-key.ts
index 78ec818fc..b4660fe2f 100644
--- a/drizzle-orm/src/primary-key.ts
+++ b/drizzle-orm/src/primary-key.ts
@@ -1,6 +1,6 @@
 import { entityKind } from '~/entity.ts';
-import { type AnyColumn } from './column.ts';
-import { type Table } from './table.ts';
+import type { AnyColumn } from './column.ts';
+import type { Table } from './table.ts';
 
 export abstract class PrimaryKey {
 	static readonly [entityKind]: string = 'PrimaryKey';
diff --git a/drizzle-orm/src/relations.ts b/drizzle-orm/src/relations.ts
index 55c29c3cf..5bd0d6398 100644
--- a/drizzle-orm/src/relations.ts
+++ b/drizzle-orm/src/relations.ts
@@ -30,7 +30,7 @@ import {
 	SQL,
 	sql,
 } from './sql/index.ts';
-import { type Assume, type ColumnsWithTable, type Equal, type Simplify, type ValueOrArray } from './utils.ts';
+import type { Assume, ColumnsWithTable, Equal, Simplify, ValueOrArray } from './utils.ts';
 
 export abstract class Relation<TTableName extends string = string> {
 	static readonly [entityKind]: string = 'Relation';
diff --git a/drizzle-orm/src/sql-js/driver.ts b/drizzle-orm/src/sql-js/driver.ts
index b35912c87..2e7080721 100644
--- a/drizzle-orm/src/sql-js/driver.ts
+++ b/drizzle-orm/src/sql-js/driver.ts
@@ -8,7 +8,7 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { SQLJsSession } from './session.ts';
 
 export type SQLJsDatabase<
diff --git a/drizzle-orm/src/sql-js/session.ts b/drizzle-orm/src/sql-js/session.ts
index c58fdf396..24d173857 100644
--- a/drizzle-orm/src/sql-js/session.ts
+++ b/drizzle-orm/src/sql-js/session.ts
@@ -2,7 +2,7 @@ import type { BindParams, Database, Statement } from 'sql.js';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
diff --git a/drizzle-orm/src/sqlite-core/alias.ts b/drizzle-orm/src/sqlite-core/alias.ts
index 4fd9414ce..bb873baa9 100644
--- a/drizzle-orm/src/sqlite-core/alias.ts
+++ b/drizzle-orm/src/sqlite-core/alias.ts
@@ -1,8 +1,8 @@
 import { TableAliasProxyHandler } from '~/alias.ts';
-import { type BuildAliasTable } from './query-builders/select.types.ts';
+import type { BuildAliasTable } from './query-builders/select.types.ts';
 
-import { type SQLiteTable } from './table.ts';
-import { type SQLiteViewBase } from './view.ts';
+import type { SQLiteTable } from './table.ts';
+import type { SQLiteViewBase } from './view.ts';
 
 export function alias<TTable extends SQLiteTable | SQLiteViewBase, TAlias extends string>(
 	table: TTable,
diff --git a/drizzle-orm/src/sqlite-core/columns/blob.ts b/drizzle-orm/src/sqlite-core/columns/blob.ts
index fd38a1934..50a94c068 100644
--- a/drizzle-orm/src/sqlite-core/columns/blob.ts
+++ b/drizzle-orm/src/sqlite-core/columns/blob.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
 type BlobMode = 'buffer' | 'json' | 'bigint';
diff --git a/drizzle-orm/src/sqlite-core/columns/common.ts b/drizzle-orm/src/sqlite-core/columns/common.ts
index 532f272a9..83a5e175d 100644
--- a/drizzle-orm/src/sqlite-core/columns/common.ts
+++ b/drizzle-orm/src/sqlite-core/columns/common.ts
@@ -13,7 +13,7 @@ import { entityKind } from '~/entity.ts';
 import type { ForeignKey, UpdateDeleteAction } from '~/sqlite-core/foreign-keys.ts';
 import { ForeignKeyBuilder } from '~/sqlite-core/foreign-keys.ts';
 import type { AnySQLiteTable, SQLiteTable } from '~/sqlite-core/table.ts';
-import { type Update } from '~/utils.ts';
+import type { Update } from '~/utils.ts';
 import { uniqueKeyName } from '../unique-constraint.ts';
 
 export interface ReferenceConfig {
diff --git a/drizzle-orm/src/sqlite-core/columns/custom.ts b/drizzle-orm/src/sqlite-core/columns/custom.ts
index 7fc1ae47c..5e0ff5732 100644
--- a/drizzle-orm/src/sqlite-core/columns/custom.ts
+++ b/drizzle-orm/src/sqlite-core/columns/custom.ts
@@ -3,7 +3,7 @@ import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { SQL } from '~/sql/index.ts';
 import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
-import { type Equal } from '~/utils.ts';
+import type { Equal } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
 export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
diff --git a/drizzle-orm/src/sqlite-core/columns/integer.ts b/drizzle-orm/src/sqlite-core/columns/integer.ts
index 957f6fbdb..86db7b08a 100644
--- a/drizzle-orm/src/sqlite-core/columns/integer.ts
+++ b/drizzle-orm/src/sqlite-core/columns/integer.ts
@@ -10,7 +10,7 @@ import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import { sql } from '~/sql/index.ts';
 import type { OnConflict } from '~/sqlite-core/utils.ts';
-import { type Equal, type Or } from '~/utils.ts';
+import type { Equal, Or } from '~/utils.ts';
 import type { AnySQLiteTable } from '../table.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
diff --git a/drizzle-orm/src/sqlite-core/columns/text.ts b/drizzle-orm/src/sqlite-core/columns/text.ts
index e5fe65fc5..4b1285259 100644
--- a/drizzle-orm/src/sqlite-core/columns/text.ts
+++ b/drizzle-orm/src/sqlite-core/columns/text.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
-import { type Equal, type Writable } from '~/utils.ts';
+import type { Equal, Writable } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
 
 export type SQLiteTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = SQLiteTextBuilder<{
diff --git a/drizzle-orm/src/sqlite-core/db.ts b/drizzle-orm/src/sqlite-core/db.ts
index a4a9fac21..ccecd9f48 100644
--- a/drizzle-orm/src/sqlite-core/db.ts
+++ b/drizzle-orm/src/sqlite-core/db.ts
@@ -1,9 +1,9 @@
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import {
-	type ExtractTablesWithRelations,
-	type RelationalSchemaConfig,
-	type TablesRelationalConfig,
+import type {
+	ExtractTablesWithRelations,
+	RelationalSchemaConfig,
+	TablesRelationalConfig,
 } from '~/relations.ts';
 import type { SQLWrapper } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
@@ -23,8 +23,8 @@ import type {
 } from '~/sqlite-core/session.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import { type DrizzleTypeError } from '~/utils.ts';
-import { type ColumnsSelection } from '~/view.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
+import type { ColumnsSelection } from '~/view.ts';
 import { RelationalQueryBuilder } from './query-builders/query.ts';
 import { SQLiteRaw } from './query-builders/raw.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
diff --git a/drizzle-orm/src/sqlite-core/indexes.ts b/drizzle-orm/src/sqlite-core/indexes.ts
index d3efb8cde..8bb004940 100644
--- a/drizzle-orm/src/sqlite-core/indexes.ts
+++ b/drizzle-orm/src/sqlite-core/indexes.ts
@@ -1,6 +1,6 @@
 import { entityKind } from '~/entity.ts';
 import type { SQL } from '~/sql/index.ts';
-import { type SQLiteColumn } from './columns/index.ts';
+import type { SQLiteColumn } from './columns/index.ts';
 import type { SQLiteTable } from './table.ts';
 
 export interface IndexConfig {
diff --git a/drizzle-orm/src/sqlite-core/query-builders/query.ts b/drizzle-orm/src/sqlite-core/query-builders/query.ts
index a7a100f7d..b301acdb2 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/query.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/query.ts
@@ -9,11 +9,11 @@ import {
 	type TablesRelationalConfig,
 } from '~/relations.ts';
 import type { RunnableQuery } from '~/runnable-query.ts';
-import { type Query, type QueryWithTypings, type SQL, type SQLWrapper } from '~/sql/index.ts';
-import { type KnownKeysOnly } from '~/utils.ts';
-import { type SQLiteDialect } from '../dialect.ts';
+import type { Query, QueryWithTypings, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { KnownKeysOnly } from '~/utils.ts';
+import type { SQLiteDialect } from '../dialect.ts';
 import type { PreparedQueryConfig, SQLitePreparedQuery, SQLiteSession } from '../session.ts';
-import { type SQLiteTable } from '../table.ts';
+import type { SQLiteTable } from '../table.ts';
 
 export type SQLiteRelationalQueryKind<TMode extends 'sync' | 'async', TResult> = TMode extends 'async'
 	? SQLiteRelationalQuery<TMode, TResult>
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 62260b8e4..d2cb53df8 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -22,7 +22,7 @@ import type {
 } from '~/query-builders/select.types.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
-import { type ColumnsSelection, type View } from '~/view.ts';
+import type { ColumnsSelection, View } from '~/view.ts';
 import type { SQLitePreparedQuery } from '../session.ts';
 import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.ts';
 import type { SQLiteSelectBase, SQLiteSelectQueryBuilderBase } from './select.ts';
diff --git a/drizzle-orm/src/sqlite-core/session.ts b/drizzle-orm/src/sqlite-core/session.ts
index 0f221d8b4..d4afb4f9d 100644
--- a/drizzle-orm/src/sqlite-core/session.ts
+++ b/drizzle-orm/src/sqlite-core/session.ts
@@ -1,6 +1,6 @@
 import { entityKind } from '~/entity.ts';
 import { DrizzleError, TransactionRollbackError } from '~/errors.ts';
-import { type TablesRelationalConfig } from '~/relations.ts';
+import type { TablesRelationalConfig } from '~/relations.ts';
 import type { PreparedQuery } from '~/session.ts';
 import type { Query, SQL } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
diff --git a/drizzle-orm/src/sqlite-core/subquery.ts b/drizzle-orm/src/sqlite-core/subquery.ts
index 626241594..be16261a6 100644
--- a/drizzle-orm/src/sqlite-core/subquery.ts
+++ b/drizzle-orm/src/sqlite-core/subquery.ts
@@ -1,6 +1,6 @@
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import type { Subquery, WithSubquery } from '~/subquery.ts';
-import { type ColumnsSelection } from '~/view.ts';
+import type { ColumnsSelection } from '~/view.ts';
 
 export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
 	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'sqlite'>>
diff --git a/drizzle-orm/src/sqlite-proxy/driver.ts b/drizzle-orm/src/sqlite-proxy/driver.ts
index 1d2a33cd9..de560f2f1 100644
--- a/drizzle-orm/src/sqlite-proxy/driver.ts
+++ b/drizzle-orm/src/sqlite-proxy/driver.ts
@@ -7,7 +7,7 @@ import {
 } from '~/relations.ts';
 import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
 import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { SQLiteRemoteSession } from './session.ts';
 
 export interface SqliteRemoteResult<T = unknown> {
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index a2adc01f6..b92a58465 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -1,9 +1,9 @@
 import type { AnyColumn } from './column.ts';
 import { Column } from './column.ts';
 import { is } from './entity.ts';
-import { type Logger } from './logger.ts';
+import type { Logger } from './logger.ts';
 import type { SelectedFieldsOrdered } from './operations.ts';
-import { type TableLike } from './query-builders/select.types.ts';
+import type { TableLike } from './query-builders/select.types.ts';
 import { Param, SQL } from './sql/index.ts';
 import type { DriverValueDecoder } from './sql/index.ts';
 import { Subquery, SubqueryConfig } from './subquery.ts';
diff --git a/drizzle-orm/src/vercel-postgres/driver.ts b/drizzle-orm/src/vercel-postgres/driver.ts
index 91fd5c3a2..bdbc49def 100644
--- a/drizzle-orm/src/vercel-postgres/driver.ts
+++ b/drizzle-orm/src/vercel-postgres/driver.ts
@@ -9,7 +9,7 @@ import {
 	type RelationalSchemaConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { type DrizzleConfig } from '~/utils.ts';
+import type { DrizzleConfig } from '~/utils.ts';
 import { type VercelPgClient, type VercelPgQueryResultHKT, VercelPgSession } from './session.ts';
 
 export interface VercelPgDriverOptions {
diff --git a/drizzle-orm/src/vercel-postgres/session.ts b/drizzle-orm/src/vercel-postgres/session.ts
index cbb714935..2dde91f6d 100644
--- a/drizzle-orm/src/vercel-postgres/session.ts
+++ b/drizzle-orm/src/vercel-postgres/session.ts
@@ -13,7 +13,7 @@ import { type PgDialect, PgTransaction } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
-import { type RelationalSchemaConfig, type TablesRelationalConfig } from '~/relations.ts';
+import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
diff --git a/drizzle-orm/type-tests/mysql/tables.ts b/drizzle-orm/type-tests/mysql/tables.ts
index ea1aaf42d..aad863086 100644
--- a/drizzle-orm/type-tests/mysql/tables.ts
+++ b/drizzle-orm/type-tests/mysql/tables.ts
@@ -1,6 +1,6 @@
 import { type Equal, Expect } from 'type-tests/utils.ts';
 import { eq, gt } from '~/expressions.ts';
-import { type BuildColumn, type InferSelectModel, type Simplify } from '~/index.ts';
+import type { BuildColumn, InferSelectModel, Simplify } from '~/index.ts';
 import {
 	bigint,
 	char,
diff --git a/drizzle-orm/type-tests/pg/array.ts b/drizzle-orm/type-tests/pg/array.ts
index 104849901..03ea190b4 100644
--- a/drizzle-orm/type-tests/pg/array.ts
+++ b/drizzle-orm/type-tests/pg/array.ts
@@ -1,5 +1,5 @@
 import { type Equal, Expect } from 'type-tests/utils.ts';
-import { type Column } from '~/column.ts';
+import type { Column } from '~/column.ts';
 import { integer, pgTable } from '~/pg-core/index.ts';
 
 {
diff --git a/drizzle-orm/type-tests/sqlite/delete.ts b/drizzle-orm/type-tests/sqlite/delete.ts
index f35581233..91f0376c9 100644
--- a/drizzle-orm/type-tests/sqlite/delete.ts
+++ b/drizzle-orm/type-tests/sqlite/delete.ts
@@ -5,7 +5,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { sql } from '~/sql/index.ts';
 import type { SQLiteDelete } from '~/sqlite-core/index.ts';
-import { type DrizzleTypeError } from '~/utils.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-orm/type-tests/sqlite/insert.ts b/drizzle-orm/type-tests/sqlite/insert.ts
index 185c937eb..17f89b600 100644
--- a/drizzle-orm/type-tests/sqlite/insert.ts
+++ b/drizzle-orm/type-tests/sqlite/insert.ts
@@ -4,7 +4,7 @@ import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/expressions.ts';
 import { sql } from '~/sql/index.ts';
 import type { SQLiteInsert } from '~/sqlite-core/query-builders/insert.ts';
-import { type DrizzleTypeError } from '~/utils.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
 import type { NewUser } from './tables.ts';
 import { users } from './tables.ts';
diff --git a/drizzle-orm/type-tests/sqlite/update.ts b/drizzle-orm/type-tests/sqlite/update.ts
index 0fd25bd6c..6686c836d 100644
--- a/drizzle-orm/type-tests/sqlite/update.ts
+++ b/drizzle-orm/type-tests/sqlite/update.ts
@@ -4,7 +4,7 @@ import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
 import { sql } from '~/sql/index.ts';
 import type { SQLiteUpdate } from '~/sqlite-core/query-builders/update.ts';
-import { type DrizzleTypeError } from '~/utils.ts';
+import type { DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-valibot/tests/utils.ts b/drizzle-valibot/tests/utils.ts
index 0d38bc534..19a129d4d 100644
--- a/drizzle-valibot/tests/utils.ts
+++ b/drizzle-valibot/tests/utils.ts
@@ -1,4 +1,4 @@
-import { type ExecutionContext } from 'ava';
+import type { ExecutionContext } from 'ava';
 import type { BaseSchema } from 'valibot';
 
 export function expectSchemaShape<T extends BaseSchema<any, any>>(t: ExecutionContext, expected: T) {

From 152aa37911b9897e933a4cb84701d268458e830e Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sat, 14 Oct 2023 11:03:02 -0400
Subject: [PATCH 45/72] [SQLite] fixed types, addressed comments and added new
 type tests

---
 .../src/query-builders/select.types.ts        |   2 +
 drizzle-orm/src/sqlite-core/dialect.ts        |  10 +-
 .../src/sqlite-core/query-builders/select.ts  |   4 +-
 .../query-builders/select.types.ts            | 274 ++++++++++++++++--
 .../query-builders/set-operators.ts           | 209 ++++++-------
 drizzle-orm/src/utils.ts                      |   9 +-
 .../type-tests/sqlite/set-operators.ts        | 101 ++++++-
 7 files changed, 448 insertions(+), 161 deletions(-)

diff --git a/drizzle-orm/src/query-builders/select.types.ts b/drizzle-orm/src/query-builders/select.types.ts
index 2477ba0ba..73fe41b40 100644
--- a/drizzle-orm/src/query-builders/select.types.ts
+++ b/drizzle-orm/src/query-builders/select.types.ts
@@ -165,3 +165,5 @@ export type SelectResultFields<TSelectedFields, TDeep extends boolean = true> =
 		[Key in keyof TSelectedFields & string]: SelectResultField<TSelectedFields[Key], TDeep>;
 	}
 >;
+
+export type SetOperator = 'union' | 'intersect' | 'except';
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index 91b726572..5070f701b 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -16,7 +16,7 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { and, eq, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
+import { and, eq, Name, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
 import { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 import type {
 	SQLiteDeleteConfig,
@@ -295,19 +295,19 @@ export abstract class SQLiteDialect {
 
 		let orderBySql;
 		if (orderBy && orderBy.length > 0) {
-			const orderByValues: SQL<unknown>[] = [];
+			const orderByValues: (SQL<unknown> | Name)[] = [];
 
 			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
-			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			// which is invalid Sql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
 			for (const singleOrderBy of orderBy) {
 				if (is(singleOrderBy, SQLiteColumn)) {
-					orderByValues.push(sql.raw(singleOrderBy.name));
+					orderByValues.push(sql.identifier(singleOrderBy.name));
 				} else if (is(singleOrderBy, SQL)) {
 					for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {
 						const chunk = singleOrderBy.queryChunks[i];
 
 						if (is(chunk, SQLiteColumn)) {
-							singleOrderBy.queryChunks[i] = sql.raw(chunk.name);
+							singleOrderBy.queryChunks[i] = sql.identifier(chunk.name);
 						}
 					}
 
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.ts b/drizzle-orm/src/sqlite-core/query-builders/select.ts
index 382515d07..05359102a 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.ts
@@ -118,7 +118,7 @@ export abstract class SQLiteSelectQueryBuilderBase<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends SQLiteSetOperatorBuilder<
 	THKT,
@@ -399,7 +399,7 @@ export interface SQLiteSelectBase<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
 	SQLiteSelectQueryBuilderBase<
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index b7e7dd656..402dfb6b2 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -1,5 +1,5 @@
 import type { Placeholder, SQL } from '~/sql/index.ts';
-import type { Assume } from '~/utils.ts';
+import type { Assume, ValidateShape } from '~/utils.ts';
 
 import type { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 import type { SQLiteTable, SQLiteTableWithColumns } from '~/sqlite-core/table.ts';
@@ -9,6 +9,7 @@ import type {
 	SelectedFieldsFlat as SelectFieldsFlatBase,
 	SelectedFieldsOrdered as SelectFieldsOrderedBase,
 } from '~/operations.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	AppendToNullabilityMap,
 	AppendToResult,
@@ -19,13 +20,16 @@ import type {
 	MapColumnsToTableAlias,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import { type ColumnsSelection, type View } from '~/view.ts';
-import type { SQLitePreparedQuery } from '../session.ts';
+import type { SQLiteDialect } from '../dialect.ts';
+import type { SQLitePreparedQuery, SQLiteSession } from '../session.ts';
 import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.ts';
 import type { SQLiteSelectBase, SQLiteSelectQueryBuilderBase } from './select.ts';
+import type { SQLiteSetOperatorBase, SQLiteSetOperatorBuilder } from './set-operators.ts';
 
 export interface SQLiteSelectJoinConfig {
 	on: SQL | undefined;
@@ -162,7 +166,7 @@ export interface SQLiteSelectQueryBuilderHKT extends SQLiteSelectHKTBase {
 		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
 		this['dynamic'],
 		this['excludedMethods'],
-		this['result'],
+		Assume<this['result'], any[]>,
 		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
@@ -177,7 +181,7 @@ export interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
 		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
 		this['dynamic'],
 		this['excludedMethods'],
-		this['result'],
+		Assume<this['result'], any[]>,
 		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
@@ -209,22 +213,43 @@ export type SQLiteSelectWithout<
 	T extends AnySQLiteSelectQueryBuilder,
 	TDynamic extends boolean,
 	K extends keyof T & string,
-> = TDynamic extends true ? T : Omit<
-	SQLiteSelectKind<
-		T['_']['hkt'],
-		T['_']['tableName'],
-		T['_']['resultType'],
-		T['_']['runResult'],
-		T['_']['selection'],
-		T['_']['selectMode'],
-		T['_']['nullabilityMap'],
-		TDynamic,
-		T['_']['excludedMethods'] | K,
-		T['_']['result'],
-		T['_']['selectedFields']
-	>,
-	T['_']['excludedMethods'] | K
->;
+> = TDynamic extends true ? T
+	: Omit<
+		SQLiteSelectBase<
+			T['_']['tableName'],
+			T['_']['resultType'],
+			T['_']['runResult'],
+			T['_']['selection'],
+			T['_']['selectMode'],
+			T['_']['nullabilityMap'],
+			TDynamic,
+			T['_']['excludedMethods'] | K,
+			T['_']['result'],
+			T['_']['selectedFields']
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+// export type SQLiteSelectWithout<
+// 	T extends AnySQLiteSelectQueryBuilder,
+// 	TDynamic extends boolean,
+// 	K extends keyof T & string,
+// > = TDynamic extends true ? T : Omit<
+// 	SQLiteSelectKind<
+// 		T['_']['hkt'],
+// 		T['_']['tableName'],
+// 		T['_']['resultType'],
+// 		T['_']['runResult'],
+// 		T['_']['selection'],
+// 		T['_']['selectMode'],
+// 		T['_']['nullabilityMap'],
+// 		TDynamic,
+// 		T['_']['excludedMethods'] | K,
+// 		T['_']['result'],
+// 		T['_']['selectedFields']
+// 	>,
+// 	T['_']['excludedMethods'] | K
+// >;
 
 export type SQLiteSelectExecute<T extends AnySQLiteSelect> = T['_']['result'];
 
@@ -261,7 +286,7 @@ export type SQLiteSelectQueryBuilder<
 	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-	TResult = unknown,
+	TResult extends any[] = unknown[],
 	TSelectedFields extends ColumnsSelection = Record<string, any>,
 > = SQLiteSelectQueryBuilderBase<
 	THKT,
@@ -301,3 +326,210 @@ export type SQLiteSelect<
 > = SQLiteSelectBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
 
 export type AnySQLiteSelect = SQLiteSelectBase<any, any, any, any, any, any, any, any, any, any>;
+
+export type SetOperatorRightSelect<
+	TValue extends AnySQLiteSetOperatorBase,
+	TResult extends any[],
+> = TValue extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, infer TValueResult, any>
+	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
+			TValueObj,
+			TResult[number],
+			TypedQueryBuilder<any, TValueResult>
+		>
+	: never
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly AnySQLiteSetOperatorBase[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, infer TValueResult, any>
+		? TValueResult extends Array<infer TValueObj>
+			? Rest extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, any, any>[] ? [
+					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
+					...SetOperatorRestSelect<Rest, TResult>,
+				]
+			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+		: never
+	: TValue
+	: TValue;
+
+export interface SQLiteSetOperationConfig {
+	fields: Record<string, unknown>;
+	operator: SetOperator;
+	isAll: boolean;
+	leftSelect: AnySQLiteSetOperatorBase;
+	rightSelect: TypedQueryBuilder<any, any[]>;
+	limit?: number | Placeholder;
+	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+	offset?: number | Placeholder;
+}
+
+export interface SQLiteSetOperatorInterface<
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends
+	TypedQueryBuilder<
+		TSelectedFields,
+		TResult
+	>
+{
+	_: {
+		dialect: 'sqlite';
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly resultType: TResultType;
+		readonly runResult: TRunResult;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+	getSelectedFields: () => TSelectedFields;
+	getSetOperatorConfig: () => {
+		session: SQLiteSession<any, any, any, any> | undefined;
+		dialect: SQLiteDialect;
+		joinsNotNullableMap: Record<string, boolean>;
+		fields: Record<string, unknown>;
+	};
+}
+
+export type AnySQLiteSetOperatorBase = SQLiteSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type CreateSetOperatorFn = <
+	THKT extends SQLiteSelectHKTBase,
+	TTableName extends string | undefined,
+	TResultType extends 'sync' | 'async',
+	TRunResult,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends AnySQLiteSetOperatorBase,
+	TRest extends AnySQLiteSetOperatorBase[],
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+>(
+	leftSelect: SQLiteSetOperatorInterface<
+		THKT,
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TResult>,
+	...restSelects: SetOperatorRestSelect<TRest, TResult>
+) => SQLiteSetOperatorBase<
+	TTableName,
+	TResultType,
+	TRunResult,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnySQLiteSetOperator = SQLiteSetOperatorBase<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type SQLiteSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = SQLiteSetOperatorBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnySQLiteSetOperatorBuilder = SQLiteSetOperatorBuilder<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type SQLiteSetOperatorWithout<
+	T extends AnySQLiteSetOperator,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		SQLiteSetOperatorBase<
+			T['_']['tableName'],
+			T['_']['resultType'],
+			T['_']['runResult'],
+			T['_']['selection'],
+			T['_']['selectMode'],
+			T['_']['nullabilityMap'],
+			TDynamic,
+			T['_']['excludedMethods'] | K,
+			T['_']['result'],
+			T['_']['selectedFields']
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type SQLiteSetOperatorDynamic<T extends AnySQLiteSetOperatorBuilder> = SQLiteSetOperatorBase<
+	T['_']['tableName'],
+	T['_']['resultType'],
+	T['_']['runResult'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index 2b81c9bf5..bcf45717e 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -14,17 +14,26 @@ import type {
 	JoinNullability,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
 import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
-import { applyMixins, haveSameKeys, type PromiseOf, type ValidateShape } from '~/utils.ts';
+import { applyMixins, haveSameKeys, type PromiseOf } from '~/utils.ts';
 import type { ColumnsSelection } from '~/view.ts';
 import type { SQLiteColumn } from '../columns/common.ts';
 import type { SQLiteDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
-import type { SQLiteSelectHKTBase } from './select.types.ts';
-
-type SetOperator = 'union' | 'intersect' | 'except';
+import type {
+	AnySQLiteSetOperatorBase,
+	CreateSetOperatorFn,
+	SetOperatorRightSelect,
+	SQLiteSelectHKTBase,
+	SQLiteSetOperationConfig,
+	SQLiteSetOperatorDynamic,
+	SQLiteSetOperatorInterface,
+	SQLiteSetOperatorWithout,
+} from './select.types.ts';
 
 const getSQLiteSetOperators = () => {
 	return {
@@ -37,42 +46,6 @@ const getSQLiteSetOperators = () => {
 
 type SQLiteSetOperators = ReturnType<typeof getSQLiteSetOperators>;
 
-type SetOperatorRightSelect<
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-> = TValue extends SQLiteSetOperatorBuilder<any, any, any, any, infer TSel, infer TMode, infer TNull> ? ValidateShape<
-		SelectResult<TSel, TMode, TNull>,
-		SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-		TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
-	>
-	: TValue;
-
-type SetOperatorRestSelect<
-	TValue extends readonly TypedQueryBuilder<any, any[]>[],
-	Valid,
-> = TValue extends [infer First, ...infer Rest]
-	? First extends SQLiteSetOperatorBuilder<any, any, any, any, infer TSel, infer TMode, infer TNull>
-		? Rest extends TypedQueryBuilder<any, any[]>[] ? [
-				ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue[0]>,
-				...SetOperatorRestSelect<Rest, Valid>,
-			]
-		: ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue>
-	: never[]
-	: TValue;
-
-export interface SQLiteSetOperationConfig {
-	fields: Record<string, unknown>;
-	operator: SetOperator;
-	isAll: boolean;
-	leftSelect: SQLiteSetOperatorBuilder<any, any, any, any, any, any, any, any, any, any>;
-	rightSelect: TypedQueryBuilder<any, any[]>;
-	limit?: number | Placeholder;
-	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
-	offset?: number | Placeholder;
-}
-
 export abstract class SQLiteSetOperatorBuilder<
 	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
@@ -84,7 +57,7 @@ export abstract class SQLiteSetOperatorBuilder<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends TypedQueryBuilder<
 	TSelectedFields,
@@ -92,6 +65,21 @@ export abstract class SQLiteSetOperatorBuilder<
 > {
 	static readonly [entityKind]: string = 'SQLiteSetOperatorBuilder';
 
+	abstract override readonly _: {
+		dialect: 'sqlite';
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly resultType: TResultType;
+		readonly runResult: TRunResult;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+
 	protected abstract joinsNotNullableMap: Record<string, boolean>;
 	protected abstract config: {
 		fields: Record<string, unknown>;
@@ -113,15 +101,14 @@ export abstract class SQLiteSetOperatorBuilder<
 		};
 	}
 
-	private setOperator(
+	private createSetOperator(
 		type: SetOperator,
 		isAll: boolean,
-	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+	): <TValue extends AnySQLiteSetOperatorBase>(
 		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	) => SQLiteSetOperator<
-		THKT,
+			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => SQLiteSetOperatorBase<
 		TTableName,
 		TResultType,
 		TRunResult,
@@ -136,39 +123,25 @@ export abstract class SQLiteSetOperatorBuilder<
 		return (rightSelect) => {
 			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
 
-			return new SQLiteSetOperator<
-				THKT,
-				TTableName,
-				TResultType,
-				TRunResult,
-				TSelection,
-				TSelectMode,
-				TNullabilityMap,
-				TDynamic,
-				TExcludedMethods,
-				TResult,
-				TSelectedFields
-			>(
+			return new SQLiteSetOperatorBase(
 				type,
 				isAll,
 				this,
-				rightSelectOrig,
+				rightSelectOrig as any,
 			);
 		};
 	}
 
-	union = this.setOperator('union', false);
+	union = this.createSetOperator('union', false);
 
-	unionAll = this.setOperator('union', true);
+	unionAll = this.createSetOperator('union', true);
 
-	intersect = this.setOperator('intersect', false);
+	intersect = this.createSetOperator('intersect', false);
 
-	except = this.setOperator('except', false);
+	except = this.createSetOperator('except', false);
 }
 
-export interface SQLiteSetOperator<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	THKT extends SQLiteSelectHKTBase,
+export interface SQLiteSetOperatorBase<
 	TTableName extends string | undefined,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TResultType extends 'sync' | 'async',
@@ -182,12 +155,11 @@ export interface SQLiteSetOperator<
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult> {}
+> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult>, RunnableQuery<TResult, 'sqlite'> {}
 
-export class SQLiteSetOperator<
-	THKT extends SQLiteSelectHKTBase,
+export class SQLiteSetOperatorBase<
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
 	TRunResult,
@@ -197,10 +169,10 @@ export class SQLiteSetOperator<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends SQLiteSetOperatorBuilder<
-	THKT,
+	SQLiteSelectHKTBase,
 	TTableName,
 	TResultType,
 	TRunResult,
@@ -214,6 +186,21 @@ export class SQLiteSetOperator<
 > {
 	static readonly [entityKind]: string = 'SQLiteSetOperator';
 
+	override readonly _: {
+		dialect: 'sqlite';
+		readonly hkt: SQLiteSelectHKTBase;
+		readonly tableName: TTableName;
+		readonly resultType: TResultType;
+		readonly runResult: TRunResult;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+
 	protected joinsNotNullableMap: Record<string, boolean>;
 	protected config: SQLiteSetOperationConfig;
 	/* @internal */
@@ -223,8 +210,8 @@ export class SQLiteSetOperator<
 	constructor(
 		operator: SetOperator,
 		isAll: boolean,
-		leftSelect: SQLiteSetOperatorBuilder<
-			THKT,
+		leftSelect: SQLiteSetOperatorInterface<
+			SQLiteSelectHKTBase,
 			TTableName,
 			TResultType,
 			TRunResult,
@@ -236,7 +223,7 @@ export class SQLiteSetOperator<
 			TResult,
 			TSelectedFields
 		>,
-		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+		rightSelect: TypedQueryBuilder<any, TResult>,
 	) {
 		super();
 
@@ -264,16 +251,18 @@ export class SQLiteSetOperator<
 			isAll,
 			leftSelect,
 			rightSelect,
-		};
+		} as SQLiteSetOperationConfig;
 	}
 
-	orderBy(builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): this;
-	orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): this;
+	orderBy(
+		builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>,
+	): SQLiteSetOperatorWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): SQLiteSetOperatorWithout<this, TDynamic, 'orderBy'>;
 	orderBy(
 		...columns:
 			| [(aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
 			| (SQLiteColumn | SQL | SQL.Aliased)[]
-	): this {
+	): SQLiteSetOperatorWithout<this, TDynamic, 'orderBy'> {
 		if (typeof columns[0] === 'function') {
 			const orderBy = columns[0](
 				new Proxy(
@@ -285,17 +274,17 @@ export class SQLiteSetOperator<
 		} else {
 			this.config.orderBy = columns as (SQLiteColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
-	limit(limit: number) {
+	limit(limit: number): SQLiteSetOperatorWithout<this, TDynamic, 'limit'> {
 		this.config.limit = limit;
-		return this;
+		return this as any;
 	}
 
-	offset(offset: number | Placeholder) {
+	offset(offset: number | Placeholder): SQLiteSetOperatorWithout<this, TDynamic, 'offset'> {
 		this.config.offset = offset;
-		return this;
+		return this as any;
 	}
 
 	toSQL(): Query {
@@ -358,51 +347,35 @@ export class SQLiteSetOperator<
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
 		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
 	}
+
+	$dynamic(): SQLiteSetOperatorDynamic<this> {
+		return this as any;
+	}
 }
 
-applyMixins(SQLiteSetOperator, [QueryPromise]);
+applyMixins(SQLiteSetOperatorBase, [QueryPromise]);
 
-function setOperator(type: SetOperator, isAll: boolean): <
-	THKT extends SQLiteSelectHKTBase,
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: SQLiteSetOperatorBuilder<
-		THKT,
-		TTableName,
-		TResultType,
-		TRunResult,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		any,
-		any
-	>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-) => SQLiteSetOperator<THKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, any, any> {
+function createSetOperator(type: SetOperator, isAll: boolean): CreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		if (restSelects.length === 0) {
-			return new SQLiteSetOperator(type, isAll, leftSelect, rightSelect);
+			return new SQLiteSetOperatorBase(type, isAll, leftSelect, rightSelect as any);
 		}
 
 		const [select, ...rest] = restSelects;
 		if (!select) throw new Error('Cannot pass undefined values to any set operator');
 
-		return setOperator(type, isAll)(new SQLiteSetOperator(type, isAll, leftSelect, rightSelect), select, ...rest);
+		return createSetOperator(type, isAll)(
+			new SQLiteSetOperatorBase(type, isAll, leftSelect, rightSelect as any),
+			select as any,
+			...rest,
+		);
 	};
 }
 
-export const union = setOperator('union', false);
+export const union = createSetOperator('union', false);
 
-export const unionAll = setOperator('union', true);
+export const unionAll = createSetOperator('union', true);
 
-export const intersect = setOperator('intersect', false);
+export const intersect = createSetOperator('intersect', false);
 
-export const except = setOperator('except', false);
+export const except = createSetOperator('except', false);
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index 02420d261..c910816f1 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -210,13 +210,12 @@ export interface DrizzleConfig<TSchema extends Record<string, unknown> = Record<
 	logger?: boolean | Logger;
 	schema?: TSchema;
 }
-
 export type ValidateShape<T, ValidShape, TResult = T> = T extends ValidShape
 	? Exclude<keyof T, keyof ValidShape> extends never ? TResult
-	: Exclude<keyof T, keyof ValidShape> extends string
-		? DrizzleTypeError<`Invalid key(s): ${Exclude<keyof T, keyof ValidShape>}`>
-	: never
-	: never;
+	: DrizzleTypeError<
+		`Invalid key(s): ${Exclude<(keyof T) & (string | number | bigint | boolean | null | undefined), keyof ValidShape>}`
+	>
+	: DrizzleTypeError<`Fields need to be the same and produce the same types`>;
 
 export type KnownKeysOnly<T, U> = {
 	[K in keyof T]: K extends keyof U ? T[K] : never;
diff --git a/drizzle-orm/type-tests/sqlite/set-operators.ts b/drizzle-orm/type-tests/sqlite/set-operators.ts
index ed98dac9e..86734c2bb 100644
--- a/drizzle-orm/type-tests/sqlite/set-operators.ts
+++ b/drizzle-orm/type-tests/sqlite/set-operators.ts
@@ -1,7 +1,7 @@
 import { type Equal, Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
 import { desc, sql } from '~/sql/index.ts';
-import { except, intersect, union, unionAll } from '~/sqlite-core/index.ts';
+import { except, intersect, type SQLiteSetOperator, union, unionAll } from '~/sqlite-core/index.ts';
 import { db } from './db.ts';
 import { cities, classes, newYorkers, users } from './tables.ts';
 
@@ -113,9 +113,15 @@ const intersect2Test = await intersect(
 Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
 
 const intersectAll2Test = await intersect(
-	db.select({
-		id: cities.id,
-	}).from(cities),
+	union(
+		db.select({
+			id: cities.id,
+		}).from(cities),
+		db.select({
+			id: cities.id,
+		})
+			.from(cities).where(sql``),
+	),
 	db.select({
 		id: cities.id,
 	})
@@ -141,27 +147,92 @@ const exceptAll2Test = await except(
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
 	})
-		.from(newYorkers),
+		.from(newYorkers).where(sql``),
 	db.select({
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
-	}).from(newYorkers),
+	}).from(newYorkers).leftJoin(newYorkers, sql``),
 );
 
 Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
 
+const unionfull = await union(db.select().from(users), db.select().from(users)).orderBy(sql``).limit(1).offset(2);
+
+Expect<
+	Equal<{
+		id: number;
+		name: string | null;
+		homeCity: number;
+		currentCity: number | null;
+		serialNullable: number | null;
+		serialNotNull: number;
+		class: 'A' | 'C';
+		subClass: 'B' | 'D' | null;
+		age1: number;
+		createdAt: Date;
+		enumCol: 'a' | 'b' | 'c';
+	}[], typeof unionfull>
+>;
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+union(db.select().from(users), db.select().from(users))
+	.offset(1)
+	// @ts-expect-error - method was already called
+	.offset(2);
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+{
+	function dynamic<T extends SQLiteSetOperator>(qb: T) {
+		return qb.orderBy(sql``).limit(1).offset(2);
+	}
+
+	const qb = union(db.select().from(users), db.select().from(users)).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	.intersect(({ intersect }) =>
+		intersect(
+			db
+				.select()
+				.from(users),
+			db
+				.select()
+				.from(users),
+		)
+	);
+
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type
 // @ts-expect-error
 db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
 
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes).where(sql``));
+
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type
 // @ts-expect-error
 db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
 
 union(
-	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
@@ -169,6 +240,16 @@ union(
 	db.select().from(cities),
 );
 
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``).limit(3).$dynamic(),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+);
+
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -189,18 +270,18 @@ union(
 	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
+	db.select({ id: newYorkers.userId }).from(newYorkers),
 	db.select({ id: cities.id }).from(cities),
 );
 
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities).where(sql``),
 	db.select({ id: sql<number>`${cities.id}` }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
 	// @ts-expect-error
-	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities).where(sql``),
 );

From 3c925d61eaa240548f757c8fdf58649979cc787a Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sat, 14 Oct 2023 15:32:35 -0400
Subject: [PATCH 46/72] [SQLite] deleted commented code and improved error
 readability

---
 .../query-builders/select.types.ts            | 45 ++++++++-----------
 .../query-builders/set-operators.ts           |  4 +-
 drizzle-orm/src/utils.ts                      |  2 +-
 3 files changed, 22 insertions(+), 29 deletions(-)

diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 402dfb6b2..a53b9abab 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -230,27 +230,6 @@ export type SQLiteSelectWithout<
 		T['_']['excludedMethods'] | K
 	>;
 
-// export type SQLiteSelectWithout<
-// 	T extends AnySQLiteSelectQueryBuilder,
-// 	TDynamic extends boolean,
-// 	K extends keyof T & string,
-// > = TDynamic extends true ? T : Omit<
-// 	SQLiteSelectKind<
-// 		T['_']['hkt'],
-// 		T['_']['tableName'],
-// 		T['_']['resultType'],
-// 		T['_']['runResult'],
-// 		T['_']['selection'],
-// 		T['_']['selectMode'],
-// 		T['_']['nullabilityMap'],
-// 		TDynamic,
-// 		T['_']['excludedMethods'] | K,
-// 		T['_']['result'],
-// 		T['_']['selectedFields']
-// 	>,
-// 	T['_']['excludedMethods'] | K
-// >;
-
 export type SQLiteSelectExecute<T extends AnySQLiteSelect> = T['_']['result'];
 
 export type SQLiteSelectPrepare<T extends AnySQLiteSelect> = SQLitePreparedQuery<
@@ -316,6 +295,20 @@ export type AnySQLiteSelectQueryBuilder = SQLiteSelectQueryBuilderBase<
 	any
 >;
 
+export type SQLiteSetOperatorBaseWithResult<T extends any[]> = SQLiteSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	T,
+	any
+>;
+
 export type SQLiteSelect<
 	TTableName extends string | undefined = string | undefined,
 	TResultType extends 'sync' | 'async' = 'sync' | 'async',
@@ -328,7 +321,7 @@ export type SQLiteSelect<
 export type AnySQLiteSelect = SQLiteSelectBase<any, any, any, any, any, any, any, any, any, any>;
 
 export type SetOperatorRightSelect<
-	TValue extends AnySQLiteSetOperatorBase,
+	TValue extends SQLiteSetOperatorBaseWithResult<TResult>,
 	TResult extends any[],
 > = TValue extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, infer TValueResult, any>
 	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
@@ -340,7 +333,7 @@ export type SetOperatorRightSelect<
 	: TValue;
 
 export type SetOperatorRestSelect<
-	TValue extends readonly AnySQLiteSetOperatorBase[],
+	TValue extends readonly SQLiteSetOperatorBaseWithResult<TResult>[],
 	TResult extends any[],
 > = TValue extends [infer First, ...infer Rest]
 	? First extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, infer TValueResult, any>
@@ -351,7 +344,7 @@ export type SetOperatorRestSelect<
 				]
 			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
 		: never
-	: TValue
+	: never
 	: TValue;
 
 export interface SQLiteSetOperationConfig {
@@ -429,8 +422,8 @@ export type CreateSetOperatorFn = <
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends AnySQLiteSetOperatorBase,
-	TRest extends AnySQLiteSetOperatorBase[],
+	TValue extends SQLiteSetOperatorBaseWithResult<TResult>,
+	TRest extends SQLiteSetOperatorBaseWithResult<TResult>[],
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index bcf45717e..daa353e84 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -25,11 +25,11 @@ import type { SQLiteColumn } from '../columns/common.ts';
 import type { SQLiteDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
 import type {
-	AnySQLiteSetOperatorBase,
 	CreateSetOperatorFn,
 	SetOperatorRightSelect,
 	SQLiteSelectHKTBase,
 	SQLiteSetOperationConfig,
+	SQLiteSetOperatorBaseWithResult,
 	SQLiteSetOperatorDynamic,
 	SQLiteSetOperatorInterface,
 	SQLiteSetOperatorWithout,
@@ -104,7 +104,7 @@ export abstract class SQLiteSetOperatorBuilder<
 	private createSetOperator(
 		type: SetOperator,
 		isAll: boolean,
-	): <TValue extends AnySQLiteSetOperatorBase>(
+	): <TValue extends SQLiteSetOperatorBaseWithResult<TResult>>(
 		rightSelect:
 			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TResult>)
 			| SetOperatorRightSelect<TValue, TResult>,
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index c910816f1..8c52a1a75 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -215,7 +215,7 @@ export type ValidateShape<T, ValidShape, TResult = T> = T extends ValidShape
 	: DrizzleTypeError<
 		`Invalid key(s): ${Exclude<(keyof T) & (string | number | bigint | boolean | null | undefined), keyof ValidShape>}`
 	>
-	: DrizzleTypeError<`Fields need to be the same and produce the same types`>;
+	: never;
 
 export type KnownKeysOnly<T, U> = {
 	[K in keyof T]: K extends keyof U ? T[K] : never;

From ea3bfe659cafcce4fc5d0959a4086ac3eb6aaa6b Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Sat, 14 Oct 2023 23:30:12 +0300
Subject: [PATCH 47/72] Remove bundling, replace Rollup with tsup, add
 @arethetypeswrong/cli to pipeline

---
 .github/workflows/release-feature-branch.yaml |  45 +-
 .github/workflows/release-latest.yaml         |  37 +-
 drizzle-orm/package.json                      |  10 +-
 drizzle-orm/rollup.cjs.config.ts              |  39 -
 drizzle-orm/rollup.common.ts                  |  63 --
 drizzle-orm/rollup.esm.config.ts              |  34 -
 drizzle-orm/scripts/build.ts                  |  58 +-
 drizzle-orm/scripts/fix-imports.ts            |  91 ++
 .../src/mysql-core/columns/smallint.ts        |   5 +-
 drizzle-orm/src/mysql-core/db.ts              |   6 +-
 drizzle-orm/src/mysql-core/foreign-keys.ts    |   2 +-
 drizzle-orm/src/mysql-proxy/driver.ts         |   6 +-
 drizzle-orm/src/mysql-proxy/migrator.ts       |   8 +-
 drizzle-orm/src/mysql-proxy/session.ts        |  32 +-
 drizzle-orm/src/pg-core/db.ts                 |   6 +-
 drizzle-orm/src/pg-core/foreign-keys.ts       |   2 +-
 drizzle-orm/src/pg-core/primary-keys.ts       |   2 +-
 drizzle-orm/src/pg-proxy/driver.ts            |   4 +-
 drizzle-orm/src/pg-proxy/migrator.ts          |   4 +-
 drizzle-orm/src/pg-proxy/session.ts           |   2 +-
 drizzle-orm/src/sql/expressions/conditions.ts |  10 +-
 drizzle-orm/src/sqlite-core/db.ts             |   6 +-
 drizzle-orm/src/sqlite-core/primary-keys.ts   |   3 +-
 drizzle-orm/tsconfig.build.json               |  13 +-
 drizzle-orm/tsconfig.cjs.json                 |   6 -
 drizzle-orm/tsconfig.config.json              |   7 -
 drizzle-orm/tsconfig.esm.json                 |   7 -
 drizzle-orm/tsconfig.json                     |  19 +-
 drizzle-orm/tsup.config.ts                    |  19 +
 integration-tests/tests/mysql-proxy.test.ts   | 155 ++--
 integration-tests/tests/pg-proxy.test.ts      |  42 +-
 integration-tests/tests/pg.test.ts            |   4 +-
 package.json                                  |   5 +
 pnpm-lock.yaml                                | 804 +++++++++++++-----
 tsconfig.json                                 |   5 +-
 turbo.json                                    |  11 +-
 36 files changed, 987 insertions(+), 585 deletions(-)
 delete mode 100644 drizzle-orm/rollup.cjs.config.ts
 delete mode 100644 drizzle-orm/rollup.common.ts
 delete mode 100644 drizzle-orm/rollup.esm.config.ts
 create mode 100755 drizzle-orm/scripts/fix-imports.ts
 delete mode 100644 drizzle-orm/tsconfig.cjs.json
 delete mode 100644 drizzle-orm/tsconfig.config.json
 delete mode 100644 drizzle-orm/tsconfig.esm.json
 create mode 100644 drizzle-orm/tsup.config.ts

diff --git a/.github/workflows/release-feature-branch.yaml b/.github/workflows/release-feature-branch.yaml
index a588079f2..2f5f85b4f 100644
--- a/.github/workflows/release-feature-branch.yaml
+++ b/.github/workflows/release-feature-branch.yaml
@@ -79,11 +79,34 @@ jobs:
       - name: Install dependencies
         run: pnpm install
 
+      - name: Check preconditions
+        id: checks
+        shell: bash
+        working-directory: ${{ matrix.package }}
+        run: |
+          old_version="$(jq -r .version package.json)"
+          version="$old_version-$(git rev-parse --short HEAD)"
+          tag="${{ github.ref_name }}"
+          is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
+
+          if [[ "$is_version_published" == "true" ]]; then
+            echo "\`${{ matrix.package }}@$version\` already published, adding tag \`$tag\`" >> $GITHUB_STEP_SUMMARY
+            npm dist-tag add ${{ matrix.package }}@$version $tag
+          else
+            {
+              echo "version=$version"
+              echo "tag=$tag"
+              echo "has_new_release=true"
+            } >> $GITHUB_OUTPUT
+          fi
+
       - name: Build
+        if: steps.checks.outputs.has_new_release == 'true'
         run: |
           pnpm build
 
       - name: Run tests
+        if: steps.checks.outputs.has_new_release == 'true'
         env:
           PG_CONNECTION_STRING: postgres://postgres:postgres@localhost:5432/drizzle
           MYSQL_CONNECTION_STRING: mysql://root:root@localhost:3306/drizzle
@@ -100,22 +123,16 @@ jobs:
           fi
 
       - name: Publish
-        if: github.event_name == 'push'
+        if: github.event_name == 'push' && steps.checks.outputs.has_new_release == 'true'
         run: |
-          tag="${{ github.ref_name }}"
-          old_version="$(jq -r .version package.json)"
-          version="$old_version-$(git rev-parse --short HEAD)"
-          is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
+          tag="${{ steps.checks.outputs.tag }}"
+          version="${{ steps.checks.outputs.version }}"
 
-          if [[ "$is_version_published" == "true" ]]; then
-            echo "Version $version already published, adding tag $tag"
-            npm dist-tag add ${{ matrix.package }}@$version $tag
-          else
-            echo "Publishing ${{ matrix.package }}@$tag using version $version"
-            (cd dist && npm version $version)
-            npm run pack
-            npm run publish -- --tag $tag
-          fi
+          echo "Publishing ${{ matrix.package }}@$tag using version $version"
+          (cd dist && npm version $version)
+          npm run pack
+          npx attw package.tgz
+          npm run publish -- --tag $tag
 
           echo "npm: \`${{ matrix.package }}@$tag | ${{ matrix.package }}@$version\`" >> $GITHUB_STEP_SUMMARY
 
diff --git a/.github/workflows/release-latest.yaml b/.github/workflows/release-latest.yaml
index c49c56707..ff21eb1fd 100644
--- a/.github/workflows/release-latest.yaml
+++ b/.github/workflows/release-latest.yaml
@@ -79,8 +79,12 @@ jobs:
         run: |
           latest="$(npm view --json ${{ matrix.package }} dist-tags.latest | jq -r)"
           version="$(jq -r .version package.json)"
+          is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
 
-          if [[ "$latest" != "$version" ]]; then
+          if [[ "$is_version_published" == "true" ]]; then
+            echo "\`${{ matrix.package }}@$version\` already published, adding tag \`latest\`" >> $GITHUB_STEP_SUMMARY
+            npm dist-tag add ${{ matrix.package }}@$version latest
+          elif [[ "$latest" != "$version" ]]; then
             echo "Latest:  $latest"
             echo "Current: $version"
 
@@ -119,6 +123,24 @@ jobs:
           pnpm test --filter ${{ matrix.package }}
           fi
 
+      - name: Pack
+        if: steps.checks.outputs.has_new_release == 'true'
+        working-directory: ${{ matrix.package }}
+        shell: bash
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
+        run: |
+          npm run pack
+
+      - name: Running @arethetypeswrong/cli
+        if: steps.checks.outputs.has_new_release == 'true'
+        working-directory: ${{ matrix.package }}
+        shell: bash
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
+        run: |
+          pnpm attw package.tgz
+
       - name: Publish
         if: steps.checks.outputs.has_new_release == 'true'
         working-directory: ${{ matrix.package }}
@@ -127,21 +149,14 @@ jobs:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
         run: |
           version="${{ steps.checks.outputs.version }}"
-          is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
 
-          if [[ "$is_version_published" == "true" ]]; then
-            echo "Version $version already published, adding tag $tag"
-            npm dist-tag add ${{ matrix.package }}@$version latest
-          else
-            echo echo "Publishing ${{ matrix.package }}@$version"
-            npm run pack
-            npm run publish
-          fi
+          echo "Publishing ${{ matrix.package }}@$version"
+          npm run publish
 
           echo "npm: \`+ ${{ matrix.package }}@$version\`" >> $GITHUB_STEP_SUMMARY
 
           # Post release message to Discord
-          curl -X POST -H "Content-Type: application/json" -d "{\"embeds\": [{\"title\": \"New \`${{ matrix.package }}\` release! 🎉\", \"url\": \"https://www.npmjs.com/package/${{ matrix.package }}\", \"color\": \"12907856\", \"fields\": [{\"name\": \"Tag\", \"value\": \"\`$tag\`\"}]}]}" ${{ secrets.DISCORD_RELEASE_WEBHOOK_URL }}
+          # curl -X POST -H "Content-Type: application/json" -d "{\"embeds\": [{\"title\": \"New \`${{ matrix.package }}\` release! 🎉\", \"url\": \"https://www.npmjs.com/package/${{ matrix.package }}\", \"color\": \"12907856\", \"fields\": [{\"name\": \"Tag\", \"value\": \"\`$tag\`\"}]}]}" ${{ secrets.DISCORD_RELEASE_WEBHOOK_URL }}
 
       - name: Create GitHub release for ORM package
         uses: actions/github-script@v6
diff --git a/drizzle-orm/package.json b/drizzle-orm/package.json
index 3a28b9df7..6d2613d75 100644
--- a/drizzle-orm/package.json
+++ b/drizzle-orm/package.json
@@ -12,7 +12,7 @@
     "publish": "npm publish package.tgz"
   },
   "main": "./index.cjs",
-  "module": "./index.mjs",
+  "module": "./index.js",
   "types": "./index.d.ts",
   "sideEffects": false,
   "publishConfig": {
@@ -130,9 +130,6 @@
     "@opentelemetry/api": "^1.4.1",
     "@originjs/vite-plugin-commonjs": "^1.0.3",
     "@planetscale/database": "^1.7.0",
-    "@rollup/plugin-json": "^6.0.0",
-    "@rollup/plugin-replace": "^5.0.2",
-    "@rollup/plugin-typescript": "^11.1.1",
     "@types/better-sqlite3": "^7.6.4",
     "@types/node": "^20.2.5",
     "@types/pg": "^8.10.1",
@@ -141,16 +138,11 @@
     "better-sqlite3": "^8.4.0",
     "bun-types": "^0.6.6",
     "cpy": "^10.1.0",
-    "cpy-cli": "^5.0.0",
     "knex": "^2.4.2",
     "kysely": "^0.25.0",
     "mysql2": "^3.3.3",
     "pg": "^8.11.0",
     "postgres": "^3.3.5",
-    "rimraf": "^5.0.0",
-    "rollup": "^3.27.2",
-    "rollup-plugin-dts": "^5.3.1",
-    "rollup-plugin-typescript2": "^0.35.0",
     "sql.js": "^1.8.0",
     "sqlite3": "^5.1.2",
     "tslib": "^2.5.2",
diff --git a/drizzle-orm/rollup.cjs.config.ts b/drizzle-orm/rollup.cjs.config.ts
deleted file mode 100644
index 52f7b959e..000000000
--- a/drizzle-orm/rollup.cjs.config.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import json from '@rollup/plugin-json';
-import replace from '@rollup/plugin-replace';
-import typescript from '@rollup/plugin-typescript';
-import { defineConfig } from 'rollup';
-
-import { entries, external } from './rollup.common';
-
-export default defineConfig([
-	{
-		input: entries.reduce<Record<string, string>>((acc, entry) => {
-			const from = 'src/' + entry + '.ts';
-			const to = entry;
-			acc[to] = from;
-			return acc;
-		}, {}),
-		output: {
-			format: 'cjs',
-			dir: 'dist.new',
-			entryFileNames: '[name].cjs',
-			chunkFileNames: '[name]-[hash].cjs',
-			sourcemap: true,
-		},
-		external,
-		plugins: [
-			replace({
-				'await import': 'require',
-				preventAssignment: true,
-			}),
-			json({
-				preferConst: true,
-			}),
-			typescript({
-				tsconfig: 'tsconfig.cjs.json',
-				outputToFilesystem: true,
-				incremental: false,
-			}),
-		],
-	},
-]);
diff --git a/drizzle-orm/rollup.common.ts b/drizzle-orm/rollup.common.ts
deleted file mode 100644
index b4f6cfd08..000000000
--- a/drizzle-orm/rollup.common.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-export const entries = [
-	'index',
-	'aws-data-api/pg/index',
-	'aws-data-api/pg/migrator',
-	'better-sqlite3/index',
-	'better-sqlite3/migrator',
-	'bun-sqlite/index',
-	'bun-sqlite/migrator',
-	'd1/index',
-	'd1/migrator',
-	'vercel-postgres/migrator',
-	'vercel-postgres/index',
-	'knex/index',
-	'kysely/index',
-	'libsql/index',
-	'libsql/migrator',
-	'mysql-core/index',
-	'mysql2/index',
-	'mysql2/migrator',
-	'neon-serverless/index',
-	'neon-serverless/migrator',
-	'neon-http/index',
-	'neon-http/migrator',
-	'node-postgres/index',
-	'node-postgres/migrator',
-	'pg-core/index',
-	'planetscale-serverless/index',
-	'planetscale-serverless/migrator',
-	'postgres-js/index',
-	'postgres-js/migrator',
-	'sql-js/index',
-	'sql-js/migrator',
-	'sqlite-core/index',
-	'sqlite-proxy/index',
-	'sqlite-proxy/migrator',
-	'pg-proxy/index',
-	'pg-proxy/migrator',
-	'mysql-proxy/index',
-	'mysql-proxy/migrator',
-	'migrator',
-	'version',
-];
-
-export const external = [
-	/^node:/,
-	'@aws-sdk/client-rds-data',
-	'@cloudflare/workers-types',
-	'@libsql/client',
-	'@neondatabase/serverless',
-	'@planetscale/database',
-	'better-sqlite3',
-	'pg',
-	'sql.js',
-	'knex',
-	'kysely',
-	'mysql2',
-	'mysql2/promise',
-	'postgres',
-	'sqlite3',
-	'bun:sqlite',
-	'@opentelemetry/api',
-	'@vercel/postgres',
-];
diff --git a/drizzle-orm/rollup.esm.config.ts b/drizzle-orm/rollup.esm.config.ts
deleted file mode 100644
index 4b3a04910..000000000
--- a/drizzle-orm/rollup.esm.config.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import json from '@rollup/plugin-json';
-import typescript from '@rollup/plugin-typescript';
-import { defineConfig } from 'rollup';
-
-import { entries, external } from './rollup.common';
-
-export default defineConfig([
-	{
-		input: entries.reduce<Record<string, string>>((acc, entry) => {
-			const from = 'src/' + entry + '.ts';
-			const to = entry;
-			acc[to] = from;
-			return acc;
-		}, {}),
-		output: {
-			format: 'esm',
-			dir: 'dist.new',
-			entryFileNames: '[name].mjs',
-			chunkFileNames: '[name]-[hash].mjs',
-			sourcemap: true,
-		},
-		external,
-		plugins: [
-			json({
-				preferConst: true,
-			}),
-			typescript({
-				tsconfig: 'tsconfig.esm.json',
-				outputToFilesystem: true,
-				incremental: false,
-			}),
-		],
-	},
-]);
diff --git a/drizzle-orm/scripts/build.ts b/drizzle-orm/scripts/build.ts
index e5cf56a94..35057f941 100755
--- a/drizzle-orm/scripts/build.ts
+++ b/drizzle-orm/scripts/build.ts
@@ -2,10 +2,10 @@
 import 'zx/globals';
 import cpy from 'cpy';
 
-import { entries } from '../rollup.common';
+async function updateAndCopyPackageJson() {
+	const pkg = await fs.readJSON('package.json');
 
-function updateAndCopyPackageJson() {
-	const pkg = fs.readJSONSync('package.json');
+	const entries = await glob('src/**/*.ts');
 
 	pkg.exports = entries.reduce<
 		Record<string, {
@@ -21,13 +21,14 @@ function updateAndCopyPackageJson() {
 			types: string;
 		}>
 	>(
-		(acc, entry) => {
+		(acc, rawEntry) => {
+			const entry = rawEntry.match(/src\/(.*)\.ts/)![1]!;
 			const exportsEntry = entry === 'index' ? '.' : './' + entry.replace(/\/index$/, '');
-			const importEntry = `./${entry}.mjs`;
+			const importEntry = `./${entry}.js`;
 			const requireEntry = `./${entry}.cjs`;
 			acc[exportsEntry] = {
 				import: {
-					types: `./${entry}.d.mts`,
+					types: `./${entry}.d.ts`,
 					default: importEntry,
 				},
 				require: {
@@ -42,21 +43,34 @@ function updateAndCopyPackageJson() {
 		{},
 	);
 
-	fs.writeJSONSync('dist.new/package.json', pkg, { spaces: 2 });
+	await fs.writeJSON('dist.new/package.json', pkg, { spaces: 2 });
 }
 
-await $`rollup --config rollup.cjs.config.ts --configPlugin typescript`;
-await $`rollup --config rollup.esm.config.ts --configPlugin typescript`;
-await $`rimraf dist-dts && tsc -p tsconfig.dts.json && resolve-tspaths -p tsconfig.dts.json --out dist-dts`;
-await cpy('dist-dts/**/*.d.ts', 'dist.new', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.mts'),
-});
-await cpy('dist-dts/**/*.d.ts', 'dist.new', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
-});
-await cpy('dist-dts/**/*.d.ts', 'dist.new');
-fs.removeSync('dist-dts');
-fs.copySync('../README.md', 'dist.new/README.md');
-updateAndCopyPackageJson();
-fs.removeSync('dist');
-fs.renameSync('dist.new', 'dist');
+await fs.remove('dist.new');
+
+await Promise.all([
+	(async () => {
+		await $`tsup`;
+
+		await Promise.all([
+			$`tsup src/version.ts --no-config --dts --format esm --outDir dist.new`,
+			$`tsup src/version.ts --no-config --dts --format cjs --outDir dist.new`,
+		]);
+	})(),
+	(async () => {
+		await $`tsc -p tsconfig.dts.json`;
+		await cpy('dist-dts/**/*.d.ts', 'dist.new', {
+			rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
+		});
+		await cpy('dist-dts/**/*.d.ts', 'dist.new', {
+			rename: (basename) => basename.replace(/\.d\.ts$/, '.d.ts'),
+		});
+	})(),
+]);
+
+await $`scripts/fix-imports.ts`;
+
+await fs.copy('../README.md', 'dist.new/README.md');
+await updateAndCopyPackageJson();
+await fs.remove('dist');
+await fs.rename('dist.new', 'dist');
diff --git a/drizzle-orm/scripts/fix-imports.ts b/drizzle-orm/scripts/fix-imports.ts
new file mode 100755
index 000000000..5b5991dfb
--- /dev/null
+++ b/drizzle-orm/scripts/fix-imports.ts
@@ -0,0 +1,91 @@
+#!/usr/bin/env -S pnpm tsx
+import 'zx/globals';
+
+import path from 'node:path';
+import { parse, print, visit } from 'recast';
+import parser from 'recast/parsers/typescript';
+
+function resolvePathAlias(importPath: string, file: string) {
+	if (importPath.startsWith('~/')) {
+		const relativePath = path.relative(path.dirname(file), path.resolve('dist.new', importPath.slice(2)));
+		importPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
+	}
+
+	return importPath;
+}
+
+function fixImportPath(importPath: string, file: string, ext: string) {
+	importPath = resolvePathAlias(importPath, file);
+
+	if (!/\..*\.(js|ts)$/.test(importPath)) {
+		return importPath;
+	}
+
+	return importPath.replace(/\.(js|ts)$/, ext);
+}
+
+const cjsFiles = await glob('dist.new/**/*.{cjs,d.cts}');
+
+for (const file of cjsFiles) {
+	const code = parse(await fs.readFile(file, 'utf8'), { parser });
+
+	visit(code, {
+		visitImportDeclaration(path) {
+			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
+			return false;
+		},
+		visitExportAllDeclaration(path) {
+			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
+			return false;
+		},
+		visitExportNamedDeclaration(path) {
+			if (path.value.source) {
+				path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
+			}
+			return false;
+		},
+		visitCallExpression(path) {
+			if (path.value.callee.type === 'Identifier' && path.value.callee.name === 'require') {
+				path.value.arguments[0].value = fixImportPath(path.value.arguments[0].value, file, '.cjs');
+			}
+			this.traverse(path);
+		},
+		visitTSImportType(path) {
+			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
+			this.traverse(path);
+		},
+	});
+
+	await fs.writeFile(file, print(code).code);
+}
+
+const esmFiles = await glob('dist.new/**/*.{js,d.ts}');
+
+for (const file of esmFiles) {
+	const code = parse(await fs.readFile(file, 'utf8'), { parser });
+
+	// console.log(code);
+
+	visit(code, {
+		visitImportDeclaration(path) {
+			path.value.source.value = resolvePathAlias(path.value.source.value, file);
+			this.traverse(path);
+		},
+		visitExportAllDeclaration(path) {
+			path.value.source.value = resolvePathAlias(path.value.source.value, file);
+			this.traverse(path);
+		},
+		visitExportNamedDeclaration(path) {
+			if (path.value.source) {
+				path.value.source.value = resolvePathAlias(path.value.source.value, file);
+			}
+			this.traverse(path);
+		},
+		visitTSImportType(path) {
+			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
+			this.traverse(path);
+		},
+	});
+
+	await fs.writeFile(file, print(code).code);
+}
diff --git a/drizzle-orm/src/mysql-core/columns/smallint.ts b/drizzle-orm/src/mysql-core/columns/smallint.ts
index 18676651a..e4653f5dd 100644
--- a/drizzle-orm/src/mysql-core/columns/smallint.ts
+++ b/drizzle-orm/src/mysql-core/columns/smallint.ts
@@ -52,6 +52,9 @@ export class MySqlSmallInt<T extends ColumnBaseConfig<'number', 'MySqlSmallInt'>
 	}
 }
 
-export function smallint<TName extends string>(name: TName, config?: MySqlIntConfig): MySqlSmallIntBuilderInitial<TName> {
+export function smallint<TName extends string>(
+	name: TName,
+	config?: MySqlIntConfig,
+): MySqlSmallIntBuilderInitial<TName> {
 	return new MySqlSmallIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/mysql-core/db.ts b/drizzle-orm/src/mysql-core/db.ts
index 11ee57fcd..6611712ce 100644
--- a/drizzle-orm/src/mysql-core/db.ts
+++ b/drizzle-orm/src/mysql-core/db.ts
@@ -1,11 +1,7 @@
 import type { ResultSetHeader } from 'mysql2/promise';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	ExtractTablesWithRelations,
-	RelationalSchemaConfig,
-	TablesRelationalConfig,
-} from '~/relations.ts';
+import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import type { SQLWrapper } from '~/sql/index.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
diff --git a/drizzle-orm/src/mysql-core/foreign-keys.ts b/drizzle-orm/src/mysql-core/foreign-keys.ts
index 5ae3d5324..957e1f15c 100644
--- a/drizzle-orm/src/mysql-core/foreign-keys.ts
+++ b/drizzle-orm/src/mysql-core/foreign-keys.ts
@@ -107,7 +107,7 @@ export function foreignKey<
 	TColumns extends [AnyMySqlColumn<{ tableName: TTableName }>, ...AnyMySqlColumn<{ tableName: TTableName }>[]],
 >(
 	config: {
-		name?: string,
+		name?: string;
 		columns: TColumns;
 		foreignColumns: ColumnsWithTable<TForeignTableName, TColumns>;
 	},
diff --git a/drizzle-orm/src/mysql-proxy/driver.ts b/drizzle-orm/src/mysql-proxy/driver.ts
index 13a289306..e9008f816 100644
--- a/drizzle-orm/src/mysql-proxy/driver.ts
+++ b/drizzle-orm/src/mysql-proxy/driver.ts
@@ -8,16 +8,16 @@ import {
 	type TablesRelationalConfig,
 } from '~/relations.ts';
 import type { DrizzleConfig } from '~/utils.ts';
-import { MySqlRemoteSession, type MySqlRemoteQueryResultHKT, type MySqlRemotePreparedQueryHKT } from './session.ts';
+import { type MySqlRemotePreparedQueryHKT, type MySqlRemoteQueryResultHKT, MySqlRemoteSession } from './session.ts';
 
 export type MySqlRemoteDatabase<
 	TSchema extends Record<string, unknown> = Record<string, never>,
-> = MySqlDatabase<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT,  TSchema>;
+> = MySqlDatabase<MySqlRemoteQueryResultHKT, MySqlRemotePreparedQueryHKT, TSchema>;
 
 export type RemoteCallback = (
 	sql: string,
 	params: any[],
-	method: 'all' | 'execute'
+	method: 'all' | 'execute',
 ) => Promise<{ rows: any[] }>;
 
 export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
diff --git a/drizzle-orm/src/mysql-proxy/migrator.ts b/drizzle-orm/src/mysql-proxy/migrator.ts
index 1ca0e799b..f071888c7 100644
--- a/drizzle-orm/src/mysql-proxy/migrator.ts
+++ b/drizzle-orm/src/mysql-proxy/migrator.ts
@@ -11,7 +11,7 @@ export async function migrate<TSchema extends Record<string, unknown>>(
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	
+
 	const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
 	const migrationTableCreate = sql`
 		create table if not exists ${sql.identifier(migrationsTable)} (
@@ -27,7 +27,7 @@ export async function migrate<TSchema extends Record<string, unknown>>(
 		hash: sql.raw('hash'),
 		created_at: sql.raw('created_at'),
 	}).from(sql.raw(migrationsTable)).orderBy(
-		sql.raw('created_at desc')
+		sql.raw('created_at desc'),
 	).limit(1);
 
 	const lastDbMigration = dbMigrations[0];
@@ -41,7 +41,9 @@ export async function migrate<TSchema extends Record<string, unknown>>(
 		) {
 			queriesToRun.push(
 				...migration.sql,
-				`insert into ${sql.identifier(migrationsTable)} (\`hash\`, \`created_at\`) values(${migration.hash}, ${migration.folderMillis})`,
+				`insert into ${
+					sql.identifier(migrationsTable)
+				} (\`hash\`, \`created_at\`) values(${migration.hash}, ${migration.folderMillis})`,
 			);
 		}
 	}
diff --git a/drizzle-orm/src/mysql-proxy/session.ts b/drizzle-orm/src/mysql-proxy/session.ts
index fd57015eb..4d9a7b16a 100644
--- a/drizzle-orm/src/mysql-proxy/session.ts
+++ b/drizzle-orm/src/mysql-proxy/session.ts
@@ -1,20 +1,23 @@
+import type { FieldPacket, ResultSetHeader } from 'mysql2/promise';
 import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
+import type { MySqlDialect } from '~/mysql-core/dialect.ts';
 import { MySqlTransaction } from '~/mysql-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/mysql-core/query-builders/select.types.ts';
-import type { MySqlTransactionConfig, QueryResultHKT , PreparedQueryConfig, PreparedQueryHKT, PreparedQueryKind } from '~/mysql-core/session.ts';
+import type {
+	MySqlTransactionConfig,
+	PreparedQueryConfig,
+	PreparedQueryHKT,
+	PreparedQueryKind,
+	QueryResultHKT,
+} from '~/mysql-core/session.ts';
+import { MySqlSession, PreparedQuery as PreparedQueryBase } from '~/mysql-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders} from '~/sql/index.ts';
-import type { SQL, Query } from '~/sql/index.ts';
-import { mapResultRow, type Assume } from '~/utils.ts';
+import { fillPlaceholders } from '~/sql/index.ts';
+import type { Query, SQL } from '~/sql/index.ts';
+import { type Assume, mapResultRow } from '~/utils.ts';
 import type { RemoteCallback } from './driver.ts';
-import { MySqlSession, PreparedQuery as PreparedQueryBase } from '~/mysql-core/session.ts';
-import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type {
-	FieldPacket,
-	ResultSetHeader,
-} from 'mysql2/promise';
 
 export type MySqlRawQueryResult = [ResultSetHeader, FieldPacket[]];
 
@@ -45,7 +48,14 @@ export class MySqlRemoteSession<
 		fields: SelectedFieldsOrdered | undefined,
 		customResultMapper?: (rows: unknown[][]) => T['execute'],
 	): PreparedQueryKind<MySqlRemotePreparedQueryHKT, T> {
-		return new PreparedQuery(this.client, query.sql, query.params, this.logger, fields, customResultMapper) as PreparedQueryKind<MySqlRemotePreparedQueryHKT, T>;
+		return new PreparedQuery(
+			this.client,
+			query.sql,
+			query.params,
+			this.logger,
+			fields,
+			customResultMapper,
+		) as PreparedQueryKind<MySqlRemotePreparedQueryHKT, T>;
 	}
 
 	override all<T = unknown>(query: SQL): Promise<T[]> {
diff --git a/drizzle-orm/src/pg-core/db.ts b/drizzle-orm/src/pg-core/db.ts
index df6bfb6a7..d5bfe5974 100644
--- a/drizzle-orm/src/pg-core/db.ts
+++ b/drizzle-orm/src/pg-core/db.ts
@@ -16,11 +16,7 @@ import type {
 } from '~/pg-core/session.ts';
 import type { PgTable } from '~/pg-core/table.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	ExtractTablesWithRelations,
-	RelationalSchemaConfig,
-	TablesRelationalConfig,
-} from '~/relations.ts';
+import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import type { SQLWrapper } from '~/sql/index.ts';
 import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
diff --git a/drizzle-orm/src/pg-core/foreign-keys.ts b/drizzle-orm/src/pg-core/foreign-keys.ts
index 42238666d..841ac4aa8 100644
--- a/drizzle-orm/src/pg-core/foreign-keys.ts
+++ b/drizzle-orm/src/pg-core/foreign-keys.ts
@@ -25,7 +25,7 @@ export class ForeignKeyBuilder {
 
 	constructor(
 		config: () => {
-			name?: string,
+			name?: string;
 			columns: PgColumn[];
 			foreignColumns: PgColumn[];
 		},
diff --git a/drizzle-orm/src/pg-core/primary-keys.ts b/drizzle-orm/src/pg-core/primary-keys.ts
index 7e2f84be1..98d7d3e79 100644
--- a/drizzle-orm/src/pg-core/primary-keys.ts
+++ b/drizzle-orm/src/pg-core/primary-keys.ts
@@ -9,7 +9,7 @@ export function primaryKey<
 >(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
 /**
  * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
- * @param columns 
+ * @param columns
  */
 export function primaryKey<
 	TTableName extends string,
diff --git a/drizzle-orm/src/pg-proxy/driver.ts b/drizzle-orm/src/pg-proxy/driver.ts
index 2b331d0eb..2c03dfb61 100644
--- a/drizzle-orm/src/pg-proxy/driver.ts
+++ b/drizzle-orm/src/pg-proxy/driver.ts
@@ -8,7 +8,7 @@ import {
 	type TablesRelationalConfig,
 } from '~/relations.ts';
 import type { DrizzleConfig } from '~/utils.ts';
-import { PgRemoteSession, type PgRemoteQueryResultHKT } from './session.ts';
+import { type PgRemoteQueryResultHKT, PgRemoteSession } from './session.ts';
 
 export type PgRemoteDatabase<
 	TSchema extends Record<string, unknown> = Record<string, never>,
@@ -17,7 +17,7 @@ export type PgRemoteDatabase<
 export type RemoteCallback = (
 	sql: string,
 	params: any[],
-	method: 'all' | 'execute'
+	method: 'all' | 'execute',
 ) => Promise<{ rows: any[] }>;
 
 export function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(
diff --git a/drizzle-orm/src/pg-proxy/migrator.ts b/drizzle-orm/src/pg-proxy/migrator.ts
index d1519de84..70b8c8615 100644
--- a/drizzle-orm/src/pg-proxy/migrator.ts
+++ b/drizzle-orm/src/pg-proxy/migrator.ts
@@ -11,7 +11,7 @@ export async function migrate<TSchema extends Record<string, unknown>>(
 	config: string | MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);
-	
+
 	const migrationTableCreate = sql`
 		CREATE TABLE IF NOT EXISTS "drizzle"."__drizzle_migrations" (
 			id SERIAL PRIMARY KEY,
@@ -24,7 +24,7 @@ export async function migrate<TSchema extends Record<string, unknown>>(
 	await db.execute(migrationTableCreate);
 
 	const dbMigrations = await db.execute(
-		sql`SELECT id, hash, created_at FROM "drizzle"."__drizzle_migrations" ORDER BY created_at DESC LIMIT 1`
+		sql`SELECT id, hash, created_at FROM "drizzle"."__drizzle_migrations" ORDER BY created_at DESC LIMIT 1`,
 	) as unknown as [number, string, string][];
 
 	const lastDbMigration = dbMigrations[0] ?? undefined;
diff --git a/drizzle-orm/src/pg-proxy/session.ts b/drizzle-orm/src/pg-proxy/session.ts
index 8461df9aa..444decb6b 100644
--- a/drizzle-orm/src/pg-proxy/session.ts
+++ b/drizzle-orm/src/pg-proxy/session.ts
@@ -9,7 +9,7 @@ import { PgSession, PreparedQuery as PreparedQueryBase } from '~/pg-core/session
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { fillPlaceholders, type Query } from '~/sql/index.ts';
 import { tracer } from '~/tracing.ts';
-import { mapResultRow, type Assume } from '~/utils.ts';
+import { type Assume, mapResultRow } from '~/utils.ts';
 import type { RemoteCallback } from './driver.ts';
 
 export interface PgRemoteSessionOptions {
diff --git a/drizzle-orm/src/sql/expressions/conditions.ts b/drizzle-orm/src/sql/expressions/conditions.ts
index 774760366..3a2f78bfd 100644
--- a/drizzle-orm/src/sql/expressions/conditions.ts
+++ b/drizzle-orm/src/sql/expressions/conditions.ts
@@ -258,7 +258,7 @@ export const lte: BinaryOperator = (left: SQLWrapper, right: unknown): SQL => {
  *
  * ## Throws
  *
- * The argument passed in the second array can’t be empty:
+ * The argument passed in the second array can't be empty:
  * if an empty is provided, this method will throw.
  *
  * ## Examples
@@ -304,7 +304,7 @@ export function inArray(
  *
  * ## Throws
  *
- * The argument passed in the second array can’t be empty:
+ * The argument passed in the second array can't be empty:
  * if an empty is provided, this method will throw.
  *
  * ## Examples
@@ -613,7 +613,7 @@ export function notIlike(column: Column, value: string | SQLWrapper): SQL {
  *
  * ## Throws
  *
- * The argument passed in the second array can’t be empty:
+ * The argument passed in the second array can't be empty:
  * if an empty is provided, this method will throw.
  *
  * ## Examples
@@ -660,7 +660,7 @@ export function arrayContains(
  *
  * ## Throws
  *
- * The argument passed in the second array can’t be empty:
+ * The argument passed in the second array can't be empty:
  * if an empty is provided, this method will throw.
  *
  * ## Examples
@@ -708,7 +708,7 @@ export function arrayContained(
  *
  * ## Throws
  *
- * The argument passed in the second array can’t be empty:
+ * The argument passed in the second array can't be empty:
  * if an empty is provided, this method will throw.
  *
  * ## Examples
diff --git a/drizzle-orm/src/sqlite-core/db.ts b/drizzle-orm/src/sqlite-core/db.ts
index ccecd9f48..fdc3f0c62 100644
--- a/drizzle-orm/src/sqlite-core/db.ts
+++ b/drizzle-orm/src/sqlite-core/db.ts
@@ -1,10 +1,6 @@
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	ExtractTablesWithRelations,
-	RelationalSchemaConfig,
-	TablesRelationalConfig,
-} from '~/relations.ts';
+import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import type { SQLWrapper } from '~/sql/index.ts';
 import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import {
diff --git a/drizzle-orm/src/sqlite-core/primary-keys.ts b/drizzle-orm/src/sqlite-core/primary-keys.ts
index 1ca1c0145..ea2111c63 100644
--- a/drizzle-orm/src/sqlite-core/primary-keys.ts
+++ b/drizzle-orm/src/sqlite-core/primary-keys.ts
@@ -60,6 +60,7 @@ export class PrimaryKey {
 	}
 
 	getName(): string {
-		return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
+		return this.name
+			?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
 	}
 }
diff --git a/drizzle-orm/tsconfig.build.json b/drizzle-orm/tsconfig.build.json
index 1fb3006cb..b57ab6b00 100644
--- a/drizzle-orm/tsconfig.build.json
+++ b/drizzle-orm/tsconfig.build.json
@@ -1,15 +1,4 @@
 {
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"composite": true,
-		"baseUrl": ".",
-		"verbatimModuleSyntax": true,
-		"noEmit": true,
-		"incremental": true,
-		"paths": {
-			"~/*": ["src/*"]
-		},
-		"outDir": "dist.new"
-	},
+	"extends": "./tsconfig.json",
 	"include": ["src"]
 }
diff --git a/drizzle-orm/tsconfig.cjs.json b/drizzle-orm/tsconfig.cjs.json
deleted file mode 100644
index 4554c9386..000000000
--- a/drizzle-orm/tsconfig.cjs.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-	"extends": "./tsconfig.build.json",
-	"compilerOptions": {
-		"rootDir": "src"
-	}
-}
diff --git a/drizzle-orm/tsconfig.config.json b/drizzle-orm/tsconfig.config.json
deleted file mode 100644
index 2fe7f262b..000000000
--- a/drizzle-orm/tsconfig.config.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"compilerOptions": {
-		"composite": true
-	},
-	"include": ["./*.ts", "scripts"]
-}
diff --git a/drizzle-orm/tsconfig.esm.json b/drizzle-orm/tsconfig.esm.json
deleted file mode 100644
index 4a7f09d1d..000000000
--- a/drizzle-orm/tsconfig.esm.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-	"extends": "./tsconfig.build.json",
-	"compilerOptions": {
-		"rootDir": "src"
-	},
-	"include": ["src"]
-}
diff --git a/drizzle-orm/tsconfig.json b/drizzle-orm/tsconfig.json
index c63720fd3..6be05cc9e 100644
--- a/drizzle-orm/tsconfig.json
+++ b/drizzle-orm/tsconfig.json
@@ -1,12 +1,13 @@
 {
-	"files": [],
-	"references": [
-		{
-			"path": "./tsconfig.build.json"
+	"extends": "../tsconfig.json",
+	"compilerOptions": {
+		"baseUrl": ".",
+		"paths": {
+			"~/*": ["src/*"]
 		},
-		{
-			"path": "./tsconfig.config.json"
-		}
-	],
-	"include": ["rollup.*.ts"]
+		"declaration": true,
+		"outDir": "dist",
+		"noEmit": true
+	},
+	"include": ["src", "scripts"]
 }
diff --git a/drizzle-orm/tsup.config.ts b/drizzle-orm/tsup.config.ts
new file mode 100644
index 000000000..482596485
--- /dev/null
+++ b/drizzle-orm/tsup.config.ts
@@ -0,0 +1,19 @@
+import { globSync } from 'glob';
+import { defineConfig } from 'tsup';
+
+const entries = globSync('src/**/*.ts');
+
+export default defineConfig({
+	entry: entries,
+	outDir: 'dist.new',
+	format: ['cjs', 'esm'],
+	bundle: false,
+	splitting: false,
+	sourcemap: true,
+	outExtension({ format }) {
+		return {
+			js: format === 'cjs' ? '.cjs' : '.js',
+		};
+	},
+	tsconfig: 'tsconfig.build.json',
+});
diff --git a/integration-tests/tests/mysql-proxy.test.ts b/integration-tests/tests/mysql-proxy.test.ts
index 782039bf6..c18f4fb84 100644
--- a/integration-tests/tests/mysql-proxy.test.ts
+++ b/integration-tests/tests/mysql-proxy.test.ts
@@ -3,15 +3,7 @@ import 'dotenv/config';
 import type { TestFn } from 'ava';
 import anyTest from 'ava';
 import Docker from 'dockerode';
-import {
-	asc,
-	eq,
-	gt,
-	inArray,
-	Name,
-	placeholder,
-	sql,
-} from 'drizzle-orm';
+import { asc, eq, gt, inArray, Name, placeholder, sql } from 'drizzle-orm';
 import {
 	alias,
 	boolean,
@@ -34,9 +26,9 @@ import {
 	uniqueKeyName,
 	year,
 } from 'drizzle-orm/mysql-core';
-import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
 import { drizzle as proxyDrizzle } from 'drizzle-orm/mysql-proxy';
 import type { MySqlRemoteDatabase } from 'drizzle-orm/mysql-proxy';
+import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
 import getPort from 'get-port';
 import * as mysql from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
@@ -111,16 +103,16 @@ class ServerSimulator {
 		if (method === 'all') {
 			try {
 				const result = await this.db.query({
-                    sql,
-                    values: params,
+					sql,
+					values: params,
 					rowsAsArray: true,
-                    typeCast: function(field: any, next: any) {
-                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-                            return field.string();
-                        }
-                        return next();
-                    },
-                });
+					typeCast: function(field: any, next: any) {
+						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+							return field.string();
+						}
+						return next();
+					},
+				});
 
 				return { data: result[0] as any };
 			} catch (e: any) {
@@ -129,14 +121,14 @@ class ServerSimulator {
 		} else if (method === 'execute') {
 			try {
 				const result = await this.db.query({
-                    sql,
-                    values: params,
-                    typeCast: function(field: any, next: any) {
-                        if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
-                            return field.string();
-                        }
-                        return next();
-                    },
+					sql,
+					values: params,
+					typeCast: function(field: any, next: any) {
+						if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+							return field.string();
+						}
+						return next();
+					},
 				});
 
 				return { data: result as any };
@@ -168,7 +160,7 @@ interface Context {
 	mysqlContainer: Docker.Container;
 	db: MySqlRemoteDatabase;
 	client: mysql.Connection;
-    serverSimulator: ServerSimulator;
+	serverSimulator: ServerSimulator;
 }
 
 const test = anyTest as TestFn<Context>;
@@ -227,21 +219,21 @@ test.before(async (t) => {
 		throw lastError;
 	}
 
-    ctx.serverSimulator = new ServerSimulator(ctx.client);
+	ctx.serverSimulator = new ServerSimulator(ctx.client);
 
 	ctx.db = proxyDrizzle(async (sql, params, method) => {
-    try {
-        const response = await ctx.serverSimulator.query(sql, params, method);
-
-        if (response.error !== undefined) {
-            throw response.error;
-        }
-
-        return { rows: response.data };
-    } catch (e: any) {
-        console.error('Error from mysql proxy server:', e.message);
-        throw e;
-    }
+		try {
+			const response = await ctx.serverSimulator.query(sql, params, method);
+
+			if (response.error !== undefined) {
+				throw response.error;
+			}
+
+			return { rows: response.data };
+		} catch (e: any) {
+			console.error('Error from mysql proxy server:', e.message);
+			throw e;
+		}
 	}, { logger: ENABLE_LOGGING });
 });
 
@@ -252,47 +244,46 @@ test.after.always(async (t) => {
 });
 
 test.beforeEach(async (t) => {
-    try {
-        
-        const ctx = t.context;
-        await ctx.db.execute(sql`drop table if exists \`userstest\``);
-        await ctx.db.execute(sql`drop table if exists \`users2\``);
-        await ctx.db.execute(sql`drop table if exists \`cities\``);
-    
-        await ctx.db.execute(
-            sql`
-              create table \`userstest\` (
-                  \`id\` serial primary key,
-                  \`name\` text not null,
-                  \`verified\` boolean not null default false,
-                  \`jsonb\` json,
-                  \`created_at\` timestamp not null default now()
-              )
-            `,
-        );
-    
-        await ctx.db.execute(
-            sql`
-              create table \`users2\` (
-                  \`id\` serial primary key,
-                  \`name\` text not null,
-                  \`city_id\` int references \`cities\`(\`id\`)
-              )
-            `,
-        );
-    
-        await ctx.db.execute(
-            sql`
-              create table \`cities\` (
-                  \`id\` serial primary key,
-                  \`name\` text not null
-              )
-            `,
-        );
-    } catch (error) {
-        console.log('error', error)
-        throw error;
-    }
+	try {
+		const ctx = t.context;
+		await ctx.db.execute(sql`drop table if exists \`userstest\``);
+		await ctx.db.execute(sql`drop table if exists \`users2\``);
+		await ctx.db.execute(sql`drop table if exists \`cities\``);
+
+		await ctx.db.execute(
+			sql`
+				create table \`userstest\` (
+					\`id\` serial primary key,
+					\`name\` text not null,
+					\`verified\` boolean not null default false,
+					\`jsonb\` json,
+					\`created_at\` timestamp not null default now()
+				)
+			`,
+		);
+
+		await ctx.db.execute(
+			sql`
+				create table \`users2\` (
+					\`id\` serial primary key,
+					\`name\` text not null,
+					\`city_id\` int references \`cities\`(\`id\`)
+				)
+			`,
+		);
+
+		await ctx.db.execute(
+			sql`
+				create table \`cities\` (
+					\`id\` serial primary key,
+					\`name\` text not null
+				)
+			`,
+		);
+	} catch (error) {
+		console.log('error', error);
+		throw error;
+	}
 });
 
 test.serial('table configs: unique third param', async (t) => {
diff --git a/integration-tests/tests/pg-proxy.test.ts b/integration-tests/tests/pg-proxy.test.ts
index 8eab46897..02c48cffc 100644
--- a/integration-tests/tests/pg-proxy.test.ts
+++ b/integration-tests/tests/pg-proxy.test.ts
@@ -5,6 +5,9 @@ import anyTest from 'ava';
 import Docker from 'dockerode';
 import {
 	and,
+	arrayContained,
+	arrayContains,
+	arrayOverlaps,
 	asc,
 	eq,
 	gt,
@@ -16,11 +19,7 @@ import {
 	type SQL,
 	sql,
 	type SQLWrapper,
-	arrayContains,
-	arrayContained,
-	arrayOverlaps
 } from 'drizzle-orm';
-import { v4 as uuid } from 'uuid';
 import {
 	alias,
 	boolean,
@@ -48,12 +47,13 @@ import {
 	uuid as pgUuid,
 	varchar,
 } from 'drizzle-orm/pg-core';
-import pg from 'pg';
-import getPort from 'get-port';
-import { migrate } from 'drizzle-orm/pg-proxy/migrator';
 import { drizzle as proxyDrizzle } from 'drizzle-orm/pg-proxy';
 import type { PgRemoteDatabase } from 'drizzle-orm/pg-proxy';
-import type { Equal} from './utils.ts';
+import { migrate } from 'drizzle-orm/pg-proxy/migrator';
+import getPort from 'get-port';
+import pg from 'pg';
+import { v4 as uuid } from 'uuid';
+import type { Equal } from './utils.ts';
 import { Expect } from './utils.ts';
 
 // eslint-disable-next-line drizzle/require-entity-kind
@@ -232,7 +232,7 @@ test.before(async (t) => {
 
 	ctx.serverSimulator = new ServerSimulator(ctx.client);
 
-    ctx.db = proxyDrizzle(async (sql, params, method) => {
+	ctx.db = proxyDrizzle(async (sql, params, method) => {
 		try {
 			const response = await ctx.serverSimulator.query(sql, params, method);
 
@@ -246,8 +246,8 @@ test.before(async (t) => {
 			throw e;
 		}
 	}, {
-        logger: ENABLE_LOGGING
-    })
+		logger: ENABLE_LOGGING,
+	});
 });
 
 test.after.always(async (t) => {
@@ -1048,7 +1048,7 @@ test.serial('migrator', async (t) => {
 	await db.execute(sql`drop table if exists all_columns`);
 	await db.execute(sql`drop table if exists users12`);
 	await db.execute(sql`drop table if exists "drizzle"."__drizzle_migrations"`);
-	
+
 	await migrate(db, async (queries) => {
 		try {
 			await serverSimulator.migrations(queries);
@@ -2593,7 +2593,7 @@ test.serial('array operators', async (t) => {
 
 	const posts = pgTable('posts', {
 		id: serial('id').primaryKey(),
-		tags: text('tags').array()
+		tags: text('tags').array(),
 	});
 
 	await db.execute(sql`drop table if exists ${posts}`);
@@ -2603,17 +2603,17 @@ test.serial('array operators', async (t) => {
 	);
 
 	await db.insert(posts).values([{
-		tags: ['ORM']
+		tags: ['ORM'],
 	}, {
-		tags: ['Typescript']
+		tags: ['Typescript'],
 	}, {
-		tags: ['Typescript', 'ORM']
+		tags: ['Typescript', 'ORM'],
 	}, {
-		tags: ['Typescript', 'Frontend', 'React']
+		tags: ['Typescript', 'Frontend', 'React'],
 	}, {
-		tags: ['Typescript', 'ORM', 'Database', 'Postgres']
+		tags: ['Typescript', 'ORM', 'Database', 'Postgres'],
 	}, {
-		tags: ['Java', 'Spring', 'OOP']
+		tags: ['Java', 'Spring', 'OOP'],
 	}]);
 
 	const contains = await db.select({ id: posts.id }).from(posts)
@@ -2625,11 +2625,11 @@ test.serial('array operators', async (t) => {
 	const withSubQuery = await db.select({ id: posts.id }).from(posts)
 		.where(arrayContains(
 			posts.tags,
-			db.select({ tags: posts.tags  }).from(posts).where(eq(posts.id, 1))
+			db.select({ tags: posts.tags }).from(posts).where(eq(posts.id, 1)),
 		));
 
 	t.deepEqual(contains, [{ id: 3 }, { id: 5 }]);
 	t.deepEqual(contained, [{ id: 1 }, { id: 2 }, { id: 3 }]);
 	t.deepEqual(overlaps, [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]);
-	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }])
+	t.deepEqual(withSubQuery, [{ id: 1 }, { id: 3 }, { id: 5 }]);
 });
diff --git a/integration-tests/tests/pg.test.ts b/integration-tests/tests/pg.test.ts
index 18640ffab..211b4b1a4 100644
--- a/integration-tests/tests/pg.test.ts
+++ b/integration-tests/tests/pg.test.ts
@@ -28,6 +28,7 @@ import {
 	boolean,
 	char,
 	cidr,
+	foreignKey,
 	getMaterializedViewConfig,
 	getTableConfig,
 	getViewConfig,
@@ -42,6 +43,7 @@ import {
 	pgTable,
 	pgTableCreator,
 	pgView,
+	primaryKey,
 	serial,
 	text,
 	timestamp,
@@ -49,8 +51,6 @@ import {
 	uniqueKeyName,
 	uuid as pgUuid,
 	varchar,
-	primaryKey,
-	foreignKey,
 } from 'drizzle-orm/pg-core';
 import getPort from 'get-port';
 import pg from 'pg';
diff --git a/package.json b/package.json
index d659f2aa0..75bf5d632 100755
--- a/package.json
+++ b/package.json
@@ -11,6 +11,7 @@
     "lint": "eslint --ext ts ."
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.12.1",
     "@trivago/prettier-plugin-sort-imports": "^4.2.0",
     "@typescript-eslint/eslint-plugin": "^6.7.3",
     "@typescript-eslint/experimental-utils": "^5.62.0",
@@ -22,13 +23,17 @@
     "drizzle-orm": "workspace:./drizzle-orm/dist",
     "drizzle-orm-old": "npm:drizzle-orm@^0.27.2",
     "eslint": "^8.50.0",
+    "eslint-plugin-dprint": "^0.4.0",
     "eslint-plugin-drizzle": "link:eslint/eslint-plugin-drizzle",
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-no-instanceof": "^1.0.1",
     "eslint-plugin-unicorn": "^48.0.1",
     "eslint-plugin-unused-imports": "^3.0.0",
+    "glob": "^10.3.10",
     "prettier": "^3.0.3",
+    "recast": "^0.23.4",
     "resolve-tspaths": "^0.8.16",
+    "tsup": "^7.2.0",
     "turbo": "^1.10.14",
     "typescript": "5.2.2"
   },
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 60584ac26..04f784595 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,4 +1,4 @@
-lockfileVersion: '6.1'
+lockfileVersion: '6.0'
 
 settings:
   autoInstallPeers: true
@@ -13,6 +13,9 @@ importers:
 
   .:
     devDependencies:
+      '@arethetypeswrong/cli':
+        specifier: ^0.12.1
+        version: 0.12.1
       '@trivago/prettier-plugin-sort-imports':
         specifier: ^4.2.0
         version: 4.2.0(prettier@3.0.3)
@@ -46,6 +49,9 @@ importers:
       eslint:
         specifier: ^8.50.0
         version: 8.50.0
+      eslint-plugin-dprint:
+        specifier: ^0.4.0
+        version: 0.4.0(eslint@8.50.0)(typescript@5.2.2)
       eslint-plugin-drizzle:
         specifier: link:eslint/eslint-plugin-drizzle
         version: link:eslint/eslint-plugin-drizzle
@@ -61,12 +67,21 @@ importers:
       eslint-plugin-unused-imports:
         specifier: ^3.0.0
         version: 3.0.0(@typescript-eslint/eslint-plugin@6.7.3)(eslint@8.50.0)
+      glob:
+        specifier: ^10.3.10
+        version: 10.3.10
       prettier:
         specifier: ^3.0.3
         version: 3.0.3
+      recast:
+        specifier: ^0.23.4
+        version: 0.23.4
       resolve-tspaths:
         specifier: ^0.8.16
         version: 0.8.16(typescript@5.2.2)
+      tsup:
+        specifier: ^7.2.0
+        version: 7.2.0(typescript@5.2.2)
       turbo:
         specifier: ^1.10.14
         version: 1.10.14
@@ -97,15 +112,6 @@ importers:
       '@planetscale/database':
         specifier: ^1.7.0
         version: 1.7.0
-      '@rollup/plugin-json':
-        specifier: ^6.0.0
-        version: 6.0.0(rollup@3.27.2)
-      '@rollup/plugin-replace':
-        specifier: ^5.0.2
-        version: 5.0.2(rollup@3.27.2)
-      '@rollup/plugin-typescript':
-        specifier: ^11.1.1
-        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2)
       '@types/better-sqlite3':
         specifier: ^7.6.4
         version: 7.6.4
@@ -130,9 +136,6 @@ importers:
       cpy:
         specifier: ^10.1.0
         version: 10.1.0
-      cpy-cli:
-        specifier: ^5.0.0
-        version: 5.0.0
       knex:
         specifier: ^2.4.2
         version: 2.4.2(better-sqlite3@8.4.0)(mysql2@3.3.3)(pg@8.11.0)(sqlite3@5.1.6)
@@ -148,18 +151,6 @@ importers:
       postgres:
         specifier: ^3.3.5
         version: 3.3.5
-      rimraf:
-        specifier: ^5.0.0
-        version: 5.0.0
-      rollup:
-        specifier: ^3.27.2
-        version: 3.27.2
-      rollup-plugin-dts:
-        specifier: ^5.3.1
-        version: 5.3.1(rollup@3.27.2)(typescript@5.2.2)
-      rollup-plugin-typescript2:
-        specifier: ^0.35.0
-        version: 0.35.0(rollup@3.27.2)(typescript@5.2.2)
       sql.js:
         specifier: ^1.8.0
         version: 1.8.0
@@ -192,7 +183,7 @@ importers:
         version: 0.4.1(rollup@3.27.2)
       '@rollup/plugin-typescript':
         specifier: ^11.1.0
-        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2)
+        version: 11.1.1(rollup@3.27.2)(typescript@5.2.2)
       '@sinclair/typebox':
         specifier: ^0.29.6
         version: 0.29.6
@@ -228,7 +219,7 @@ importers:
         version: 0.4.1(rollup@3.27.2)
       '@rollup/plugin-typescript':
         specifier: ^11.1.0
-        version: 11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2)
+        version: 11.1.1(rollup@3.27.2)(typescript@5.2.2)
       '@sinclair/typebox':
         specifier: ^0.29.6
         version: 0.29.6
@@ -433,6 +424,39 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /@andrewbranch/untar.js@1.0.2:
+    resolution: {integrity: sha512-hL80MHK3b++pEp6K23+Nl5r5D1F19DRagp2ruCBIv4McyCiLKq67vUNvEQY1aGCAKNZ8GxV23n5MhOm7RwO8Pg==}
+    dev: true
+
+  /@arethetypeswrong/cli@0.12.1:
+    resolution: {integrity: sha512-5nA91oqi8GPv9NkxgcjdpyKSMJ0WCcX8YYcxlZS5XBqY6cau0pMt5S0CXU3QGgl9qDryrok1QaM1xtUUhBKTAA==}
+    hasBin: true
+    dependencies:
+      '@arethetypeswrong/core': 0.12.1
+      chalk: 4.1.2
+      cli-table3: 0.6.3
+      commander: 10.0.1
+      marked: 5.1.2
+      marked-terminal: 5.2.0(marked@5.1.2)
+      node-fetch: 2.6.11
+      semver: 7.5.4
+    transitivePeerDependencies:
+      - encoding
+    dev: true
+
+  /@arethetypeswrong/core@0.12.1:
+    resolution: {integrity: sha512-1XCwz+IRSptRu1Y48D462vu3de8sLFrtXaXkgthIZ8+iRhEBIZtu+q7MwrfR3hWbYIgUsBj2WugtIgaPAdX9FA==}
+    dependencies:
+      '@andrewbranch/untar.js': 1.0.2
+      fetch-ponyfill: 7.1.0
+      fflate: 0.7.4
+      semver: 7.5.4
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
+      validate-npm-package-name: 5.0.0
+    transitivePeerDependencies:
+      - encoding
+    dev: true
+
   /@aws-crypto/crc32@3.0.0:
     resolution: {integrity: sha512-IzSgsrxUcsrejQbPVilIKy16kAT52EwB6zSaI+M3xxIhKh5+aldEyvI+z6erM7TCLB2BJsFrtHjp6/4/sr+3dA==}
     dependencies:
@@ -481,7 +505,7 @@ packages:
     engines: {node: '>=14.0.0'}
     dependencies:
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/client-cognito-identity@3.345.0:
     resolution: {integrity: sha512-KHpJ7jZq0OGXNIJ+K0U4DcVubroXq92TD7rQi16TU7q8AnjrCoMuJz32QJI+9FEFbjmTIJ/tts9rma0PqR30bw==}
@@ -522,7 +546,7 @@ packages:
       '@aws-sdk/util-utf8': 3.310.0
       '@smithy/protocol-http': 1.0.1
       '@smithy/types': 1.0.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -651,7 +675,7 @@ packages:
       '@aws-sdk/util-utf8': 3.310.0
       '@smithy/protocol-http': 1.0.1
       '@smithy/types': 1.0.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: true
@@ -692,7 +716,7 @@ packages:
       '@aws-sdk/util-utf8': 3.310.0
       '@smithy/protocol-http': 1.0.1
       '@smithy/types': 1.0.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -733,7 +757,7 @@ packages:
       '@aws-sdk/util-utf8': 3.310.0
       '@smithy/protocol-http': 1.0.1
       '@smithy/types': 1.0.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: true
@@ -774,7 +798,7 @@ packages:
       '@aws-sdk/util-utf8': 3.310.0
       '@smithy/protocol-http': 1.0.1
       '@smithy/types': 1.0.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -864,7 +888,7 @@ packages:
       '@smithy/protocol-http': 1.0.1
       '@smithy/types': 1.0.0
       fast-xml-parser: 4.1.2
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -885,7 +909,7 @@ packages:
       '@aws-sdk/client-cognito-identity': 3.345.0
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -896,7 +920,7 @@ packages:
     dependencies:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/credential-provider-imds@3.342.0:
     resolution: {integrity: sha512-ReaHwFLfcsEYjDFvi95OFd+IU8frPwuAygwL56aiMT7Voc0oy3EqB3MFs3gzFxdLsJ0vw9TZMRbaouepAEVCkA==}
@@ -906,7 +930,7 @@ packages:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/types': 3.342.0
       '@aws-sdk/url-parser': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/credential-provider-ini@3.344.0:
     resolution: {integrity: sha512-21awwuyIG0qXirgeDdq9EbyXzk/5pZswfBem8W2EAtwNPI8HO84S0EHyHybj/5l5QdPrKd/W3ohRkKY0uXSEcQ==}
@@ -920,7 +944,7 @@ packages:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: true
@@ -937,7 +961,7 @@ packages:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -973,7 +997,7 @@ packages:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -985,7 +1009,7 @@ packages:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/credential-provider-sso@3.344.0:
     resolution: {integrity: sha512-uS8iKMyjSQch/oKSDno6k3TZ0lr/kL6ZzvBRXcOsmprgW+ffP6ZcRVOPHIwUbjLyuZtDHRq4QcSBGXCnazar+Q==}
@@ -996,7 +1020,7 @@ packages:
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/token-providers': 3.344.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: true
@@ -1010,7 +1034,7 @@ packages:
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/token-providers': 3.345.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -1021,7 +1045,7 @@ packages:
     dependencies:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/credential-providers@3.345.0:
     resolution: {integrity: sha512-rTbc1asHXnVFFiTnQBn90N7rU3ICDaFpsivkzXlo5MEbRRkxswM5QUDm0iO1g4EnGEWTNwTb6T5kwPqg+8GfVw==}
@@ -1051,7 +1075,7 @@ packages:
       '@aws-crypto/crc32': 3.0.0
       '@aws-sdk/types': 3.342.0
       '@aws-sdk/util-hex-encoding': 3.310.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/fetch-http-handler@3.342.0:
     resolution: {integrity: sha512-zsC23VUQMHEu4OKloLCVyWLG0ns6n+HKZ9euGLnNO3l0VSRne9qj/94yR+4jr/h04M7MhGf9mlczGfnZUFxs5w==}
@@ -1081,7 +1105,7 @@ packages:
     resolution: {integrity: sha512-urnbcCR+h9NWUnmOtet/s4ghvzsidFmspfhYaHAmSRdy9yDjdjBJMFjjsn85A1ODUktztm+cVncXjQ38WCMjMQ==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/middleware-content-length@3.342.0:
     resolution: {integrity: sha512-7LUMZqhihSAptGRFFQvuwt9nCLNzNPkGd1oU1RpVXw6YPQfKP9Ec5tgg4oUlv1t58IYQvdVj5ITKp4X2aUJVPg==}
@@ -1142,7 +1166,7 @@ packages:
     dependencies:
       '@aws-sdk/middleware-signing': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/middleware-serde@3.342.0:
     resolution: {integrity: sha512-WRD+Cyu6+h1ymfPnAw4fI2q3zXjihJ55HFe1uRF8VPN4uBbJNfN3IqL38y/SMEdZ0gH9zNlRNxZLhR0q6SNZEQ==}
@@ -1185,7 +1209,7 @@ packages:
       '@aws-sdk/protocol-http': 3.342.0
       '@aws-sdk/types': 3.342.0
       '@aws-sdk/util-endpoints': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     dev: false
 
   /@aws-sdk/node-config-provider@3.342.0:
@@ -1212,14 +1236,14 @@ packages:
     engines: {node: '>=14.0.0'}
     dependencies:
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/protocol-http@3.342.0:
     resolution: {integrity: sha512-zuF2urcTJBZ1tltPdTBQzRasuGB7+4Yfs9i5l0F7lE0luK5Azy6G+2r3WWENUNxFTYuP94GrrqaOhVyj8XXLPQ==}
     engines: {node: '>=14.0.0'}
     dependencies:
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/querystring-builder@3.342.0:
     resolution: {integrity: sha512-tb3FbtC36a7XBYeupdKm60LeM0etp73I6/7pDAkzAlw7zJdvY0aQIvj1c0U6nZlwZF8sSSxC7vlamR+wCspdMw==}
@@ -1227,14 +1251,14 @@ packages:
     dependencies:
       '@aws-sdk/types': 3.342.0
       '@aws-sdk/util-uri-escape': 3.310.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/querystring-parser@3.342.0:
     resolution: {integrity: sha512-6svvr/LZW1EPJaARnOpjf92FIiK25wuO7fRq05gLTcTRAfUMDvub+oDg3Ro9EjJERumrYQrYCem5Qi4X9w8K2g==}
     engines: {node: '>=14.0.0'}
     dependencies:
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/service-error-classification@3.342.0:
     resolution: {integrity: sha512-MwHO5McbdAVKxfQj1yhleboAXqrzcGoi9ODS+bwCwRfe2lakGzBBhu8zaGDlKYOdv5rS+yAPP/5fZZUiuZY8Bw==}
@@ -1245,7 +1269,7 @@ packages:
     engines: {node: '>=14.0.0'}
     dependencies:
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/signature-v4@3.342.0:
     resolution: {integrity: sha512-OWrGO2UOa1ENpy0kYd2shK4sklQygWUqvWLx9FotDbjIeUIEfAnqoPq/QqcXVrNyT/UvPi4iIrjHJEO8JCNRmA==}
@@ -1258,7 +1282,7 @@ packages:
       '@aws-sdk/util-middleware': 3.342.0
       '@aws-sdk/util-uri-escape': 3.310.0
       '@aws-sdk/util-utf8': 3.310.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/smithy-client@3.342.0:
     resolution: {integrity: sha512-HQ4JejjHU2X7OAZPwixFG+EyPSjmoZqll7EvWjPSKyclWrM320haWWz1trVzjG/AgPfeDLfRkH/JoMr13lECew==}
@@ -1276,7 +1300,7 @@ packages:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: true
@@ -1289,7 +1313,7 @@ packages:
       '@aws-sdk/property-provider': 3.342.0
       '@aws-sdk/shared-ini-file-loader': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     transitivePeerDependencies:
       - aws-crt
     dev: false
@@ -1330,13 +1354,13 @@ packages:
     engines: {node: '>=14.0.0'}
     dependencies:
       '@aws-sdk/is-array-buffer': 3.310.0
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/util-config-provider@3.310.0:
     resolution: {integrity: sha512-xIBaYo8dwiojCw8vnUcIL4Z5tyfb1v3yjqyJKJWV/dqKUFOOS0U591plmXbM+M/QkXyML3ypon1f8+BoaDExrg==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/util-defaults-mode-browser@3.342.0:
     resolution: {integrity: sha512-N1ZRvCLbrt4Re9MKU3pLYR0iO+H7GU7RsXG4yAq6DtSWT9WCw6xhIUpeV2T5uxWKL92o3WHNiGjwcebq+N73Bg==}
@@ -1369,19 +1393,19 @@ packages:
     resolution: {integrity: sha512-sVN7mcCCDSJ67pI1ZMtk84SKGqyix6/0A1Ab163YKn+lFBQRMKexleZzpYzNGxYzmQS6VanP/cfU7NiLQOaSfA==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/util-locate-window@3.310.0:
     resolution: {integrity: sha512-qo2t/vBTnoXpjKxlsC2e1gBrRm80M3bId27r0BRB2VniSSe7bL1mmzM+/HFtujm0iAxtPM+aLEflLJlJeDPg0w==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/util-middleware@3.342.0:
     resolution: {integrity: sha512-P2LYyMP4JUFZBy9DcMvCDxWU34mlShCyrqBZ1ouuGW7UMgRb1PTEvpLAVndIWn9H+1KGDFjMqOWp1FZHr4YZOA==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/util-retry@3.342.0:
     resolution: {integrity: sha512-U1LXXtOMAQjU4H9gjYZng8auRponAH0t3vShHMKT8UQggT6Hwz1obdXUZgcLCtcjp/1aEK4MkDwk2JSjuUTaZw==}
@@ -1394,7 +1418,7 @@ packages:
     resolution: {integrity: sha512-drzt+aB2qo2LgtDoiy/3sVG8w63cgLkqFIa2NFlGpUgHFWTXkqtbgf4L5QdjRGKWhmZsnqkbtL7vkSWEcYDJ4Q==}
     engines: {node: '>=14.0.0'}
     dependencies:
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/util-user-agent-browser@3.342.0:
     resolution: {integrity: sha512-FWHiBi1xaebzmq3LJsizgd2LCix/bKHUTOjTeO6hEYny5DyrOl0liwIA0mqgvfgwIoMOF/l6FGg7kTfKtNgkEA==}
@@ -1409,7 +1433,7 @@ packages:
     dependencies:
       '@aws-sdk/types': 3.342.0
       bowser: 2.11.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     dev: false
 
   /@aws-sdk/util-user-agent-node@3.342.0:
@@ -1437,13 +1461,13 @@ packages:
     dependencies:
       '@aws-sdk/node-config-provider': 3.342.0
       '@aws-sdk/types': 3.342.0
-      tslib: 2.5.3
+      tslib: 2.6.2
     dev: false
 
   /@aws-sdk/util-utf8-browser@3.259.0:
     resolution: {integrity: sha512-UvFa/vR+e19XookZF8RzFZBrw2EUkQWxiBW0yYQAhvk3C+QVGl0H3ouca8LDBlBfQKXwmW3huo/59H8rwb1wJw==}
     dependencies:
-      tslib: 2.5.3
+      tslib: 2.6.2
 
   /@aws-sdk/util-utf8@3.310.0:
     resolution: {integrity: sha512-DnLfFT8uCO22uOJc0pt0DsSNau1GTisngBCDw8jQuWT5CqogMJu4b/uXmwEqfj8B3GX6Xsz8zOd6JpRlPftQoA==}
@@ -1609,6 +1633,13 @@ packages:
     resolution: {integrity: sha512-IX4oJCe14ctblSPZBlW64BVZ9nYLUo6sD2I5gu3hX0ywByYWm1OuoKm9Xb/Zpbj8Ph18Z7Ryii6u2/ocnncXdA==}
     dev: true
 
+  /@colors/colors@1.5.0:
+    resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==}
+    engines: {node: '>=0.1.90'}
+    requiresBuild: true
+    dev: true
+    optional: true
+
   /@dprint/darwin-arm64@0.41.0:
     resolution: {integrity: sha512-P9PtcQI0mrI4U6yyd+/iI664BHSqC9KTS6ogq0ptEdnLtlaWzf09D1nv6FBaHiG9m3conuBRlPsoUqt3j6PZ2w==}
     cpu: [arm64]
@@ -2131,6 +2162,18 @@ packages:
     resolution: {integrity: sha512-trnsAYxU3xnS1gPHPyU961coFyLkh4gAD/0zQ5mymY4yOZ+CYvsPqUbOFSw0aDM4y0tV7tiFxL/1XfXPNC6IPg==}
     dev: false
 
+  /@isaacs/cliui@8.0.2:
+    resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
+    engines: {node: '>=12'}
+    dependencies:
+      string-width: 5.1.2
+      string-width-cjs: /string-width@4.2.3
+      strip-ansi: 7.1.0
+      strip-ansi-cjs: /strip-ansi@6.0.1
+      wrap-ansi: 8.1.0
+      wrap-ansi-cjs: /wrap-ansi@7.0.0
+    dev: true
+
   /@jridgewell/gen-mapping@0.3.3:
     resolution: {integrity: sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==}
     engines: {node: '>=6.0.0'}
@@ -2346,33 +2389,6 @@ packages:
   /@polka/url@1.0.0-next.21:
     resolution: {integrity: sha512-a5Sab1C4/icpTZVzZc5Ghpz88yQtGOyNqYXcZgOssB2uuAr+wF/MvN6bgtW32q7HHrvBki+BsZ0OuNv6EV3K9g==}
 
-  /@rollup/plugin-json@6.0.0(rollup@3.27.2):
-    resolution: {integrity: sha512-i/4C5Jrdr1XUarRhVu27EEwjt4GObltD7c+MkCIpO2QIbojw8MUs+CCTqOphQi3Qtg1FLmYt+l+6YeoIf51J7w==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      '@rollup/pluginutils': 5.0.2(rollup@3.27.2)
-      rollup: 3.27.2
-    dev: true
-
-  /@rollup/plugin-replace@5.0.2(rollup@3.27.2):
-    resolution: {integrity: sha512-M9YXNekv/C/iHHK+cvORzfRYfPbq0RDD8r0G+bMiTXjNGKulPnCT9O3Ss46WfhI6ZOCgApOP7xAdmCQJ+U2LAA==}
-    engines: {node: '>=14.0.0'}
-    peerDependencies:
-      rollup: ^1.20.0||^2.0.0||^3.0.0
-    peerDependenciesMeta:
-      rollup:
-        optional: true
-    dependencies:
-      '@rollup/pluginutils': 5.0.2(rollup@3.27.2)
-      magic-string: 0.27.0
-      rollup: 3.27.2
-    dev: true
-
   /@rollup/plugin-terser@0.4.1(rollup@3.20.7):
     resolution: {integrity: sha512-aKS32sw5a7hy+fEXVy+5T95aDIwjpGHCTv833HXVtyKMDoVS7pBr5K3L9hEQoNqbJFjfANPrNpIXlTQ7is00eA==}
     engines: {node: '>=14.0.0'}
@@ -2422,7 +2438,7 @@ packages:
       typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
-  /@rollup/plugin-typescript@11.1.1(rollup@3.27.2)(tslib@2.5.2)(typescript@5.2.2):
+  /@rollup/plugin-typescript@11.1.1(rollup@3.27.2)(typescript@5.2.2):
     resolution: {integrity: sha512-Ioir+x5Bejv72Lx2Zbz3/qGg7tvGbxQZALCLoJaGrkNXak/19+vKgKYJYM3i/fJxvsb23I9FuFQ8CUBEfsmBRg==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
@@ -2438,18 +2454,9 @@ packages:
       '@rollup/pluginutils': 5.0.2(rollup@3.27.2)
       resolve: 1.22.2
       rollup: 3.27.2
-      tslib: 2.5.2
       typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
-  /@rollup/pluginutils@4.2.1:
-    resolution: {integrity: sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ==}
-    engines: {node: '>= 8.0.0'}
-    dependencies:
-      estree-walker: 2.0.2
-      picomatch: 2.3.1
-    dev: true
-
   /@rollup/pluginutils@5.0.2(rollup@3.20.7):
     resolution: {integrity: sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA==}
     engines: {node: '>=14.0.0'}
@@ -2748,6 +2755,23 @@ packages:
       - supports-color
     dev: true
 
+  /@typescript-eslint/experimental-utils@3.10.1(eslint@8.50.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-DewqIgscDzmAfd5nOGe4zm6Bl7PKtMG2Ad0KG8CUZAHlXfAKTF9Ol5PXhiMh39yRL2ChRH1cuuUGOcVyyrhQIw==}
+    engines: {node: ^10.12.0 || >=12.0.0}
+    peerDependencies:
+      eslint: '*'
+    dependencies:
+      '@types/json-schema': 7.0.13
+      '@typescript-eslint/types': 3.10.1
+      '@typescript-eslint/typescript-estree': 3.10.1(typescript@5.2.2)
+      eslint: 8.50.0
+      eslint-scope: 5.1.1
+      eslint-utils: 2.1.0
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+    dev: true
+
   /@typescript-eslint/experimental-utils@5.62.0(eslint@8.50.0)(typescript@5.2.2):
     resolution: {integrity: sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -2818,6 +2842,11 @@ packages:
       - supports-color
     dev: true
 
+  /@typescript-eslint/types@3.10.1:
+    resolution: {integrity: sha512-+3+FCUJIahE9q0lDi1WleYzjCwJs5hIsbugIgnbB+dSCYUxl8L6PwmsyOPFZde2hc1DlTo/xnkOgiTLSyAbHiQ==}
+    engines: {node: ^8.10.0 || ^10.13.0 || >=11.10.1}
+    dev: true
+
   /@typescript-eslint/types@5.62.0:
     resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -2828,6 +2857,28 @@ packages:
     engines: {node: ^16.0.0 || >=18.0.0}
     dev: true
 
+  /@typescript-eslint/typescript-estree@3.10.1(typescript@5.2.2):
+    resolution: {integrity: sha512-QbcXOuq6WYvnB3XPsZpIwztBoquEYLXh2MtwVU+kO8jgYCiv4G5xrSP/1wg4tkvrEE+esZVquIPX/dxPlePk1w==}
+    engines: {node: ^10.12.0 || >=12.0.0}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/types': 3.10.1
+      '@typescript-eslint/visitor-keys': 3.10.1
+      debug: 4.3.4
+      glob: 7.2.3
+      is-glob: 4.0.3
+      lodash: 4.17.21
+      semver: 7.5.4
+      tsutils: 3.21.0(typescript@5.2.2)
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /@typescript-eslint/typescript-estree@5.62.0(typescript@5.2.2):
     resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -2909,6 +2960,13 @@ packages:
       - typescript
     dev: true
 
+  /@typescript-eslint/visitor-keys@3.10.1:
+    resolution: {integrity: sha512-9JgC82AaQeglebjZMgYR5wgmfUdUc+EitGUUMW8u2nDckaeimzW+VsoLV6FoimPv2id3VQzfjwBxEMVz08ameQ==}
+    engines: {node: ^8.10.0 || ^10.13.0 || >=11.10.1}
+    dependencies:
+      eslint-visitor-keys: 1.3.0
+    dev: true
+
   /@typescript-eslint/visitor-keys@5.62.0:
     resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -3082,6 +3140,13 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /ansi-escapes@6.2.0:
+    resolution: {integrity: sha512-kzRaCqXnpzWs+3z5ABPQiVke+iq0KXkHo8xiWV4RPTi5Yli0l97BEQuhXV1s7+aSU/fu1kUuxgS4MsQ0fRuygw==}
+    engines: {node: '>=14.16'}
+    dependencies:
+      type-fest: 3.13.1
+    dev: true
+
   /ansi-regex@5.0.1:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
     engines: {node: '>=8'}
@@ -3114,6 +3179,14 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
+  /ansicolors@0.3.2:
+    resolution: {integrity: sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==}
+    dev: true
+
+  /any-promise@1.3.0:
+    resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
+    dev: true
+
   /anymatch@3.1.3:
     resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
     engines: {node: '>= 8'}
@@ -3242,9 +3315,26 @@ packages:
       safer-buffer: 2.1.2
     dev: false
 
+  /assert@2.1.0:
+    resolution: {integrity: sha512-eLHpSK/Y4nhMJ07gDaAzoX/XAKS8PSaojml3M0DM4JpV1LAi5JOJ/p6H/XWrl8L+DzVEvVCW1z3vWAaB9oTsQw==}
+    dependencies:
+      call-bind: 1.0.2
+      is-nan: 1.3.2
+      object-is: 1.1.5
+      object.assign: 4.1.4
+      util: 0.12.5
+    dev: true
+
   /assertion-error@1.1.0:
     resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==}
 
+  /ast-types@0.16.1:
+    resolution: {integrity: sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg==}
+    engines: {node: '>=4'}
+    dependencies:
+      tslib: 2.6.2
+    dev: true
+
   /asynckit@0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
@@ -3497,7 +3587,6 @@ packages:
     resolution: {integrity: sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==}
     dependencies:
       semver: 7.5.4
-    dev: false
 
   /bun-types@0.6.6:
     resolution: {integrity: sha512-/LL3zPv7d+ZvHSD6TIhVB7l8h1rrMvuGlwILTGHrJJeAaHKq+7RgIV6N8A8kzhkYMFuTq9o2P/2o8gUL7RHtzg==}
@@ -3507,6 +3596,16 @@ packages:
     resolution: {integrity: sha512-XlyKVdYCHa7K5PHYGcwOVOrGE/bMnLS51y7zFA3ZAAXyiQ6dTaNXNCWTTufgII/6ruN770uhAXphQmzvU/r2fQ==}
     dev: true
 
+  /bundle-require@4.0.2(esbuild@0.18.20):
+    resolution: {integrity: sha512-jwzPOChofl67PSTW2SGubV9HBQAhhR2i6nskiOThauo9dzwDUgOWQScFVaJkjEfYX+UXiD+LEx8EblQMc2wIag==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    peerDependencies:
+      esbuild: '>=0.17'
+    dependencies:
+      esbuild: 0.18.20
+      load-tsconfig: 0.2.5
+    dev: true
+
   /busboy@1.6.0:
     resolution: {integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==}
     engines: {node: '>=10.16.0'}
@@ -3571,6 +3670,14 @@ packages:
     engines: {node: '>=14.16'}
     dev: true
 
+  /cardinal@2.1.1:
+    resolution: {integrity: sha512-JSr5eOgoEymtYHBjNWyjrMqet9Am2miJhlfKNdqLp6zoeAh0KN5dRAcxlecj5mAJrmQomgiOBj35xHLrFjqBpw==}
+    hasBin: true
+    dependencies:
+      ansicolors: 0.3.2
+      redeyed: 2.1.1
+    dev: true
+
   /cbor@8.1.0:
     resolution: {integrity: sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==}
     engines: {node: '>=12.19'}
@@ -3691,6 +3798,15 @@ packages:
       timers-ext: 0.1.7
     dev: true
 
+  /cli-table3@0.6.3:
+    resolution: {integrity: sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==}
+    engines: {node: 10.* || >= 12.*}
+    dependencies:
+      string-width: 4.2.3
+    optionalDependencies:
+      '@colors/colors': 1.5.0
+    dev: true
+
   /cli-truncate@3.1.0:
     resolution: {integrity: sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -3757,6 +3873,11 @@ packages:
     dependencies:
       delayed-stream: 1.0.0
 
+  /commander@10.0.1:
+    resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==}
+    engines: {node: '>=14'}
+    dev: true
+
   /commander@11.0.0:
     resolution: {integrity: sha512-9HMlXtt/BNoYr8ooyjjNRdIilOTkVJXB+GhxMTtOKwk0R4j4lS4NpjuqmRxroBfnfTSHQIHQB7wryHhXarNjmQ==}
     engines: {node: '>=16'}
@@ -3766,6 +3887,11 @@ packages:
     resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
     dev: true
 
+  /commander@4.1.1:
+    resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
+    engines: {node: '>= 6'}
+    dev: true
+
   /commander@9.5.0:
     resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==}
     engines: {node: ^12.20.0 || >=14}
@@ -3775,10 +3901,6 @@ packages:
     resolution: {integrity: sha512-QE33hToZseCH3jS0qN96O/bSh3kaw/h+Tq7ngyY9eWDUnTlTNUyqfqvCXioLe5Na5jFsL78ra/wuBU4iuEgd4w==}
     dev: true
 
-  /commondir@1.0.1:
-    resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
-    dev: true
-
   /concat-map@0.0.1:
     resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
     requiresBuild: true
@@ -3860,15 +3982,6 @@ packages:
     dev: false
     optional: true
 
-  /cpy-cli@5.0.0:
-    resolution: {integrity: sha512-fb+DZYbL9KHc0BC4NYqGRrDIJZPXUmjjtqdw4XRRg8iV8dIfghUX/WiL+q4/B/KFTy3sK6jsbUhBaz0/Hxg7IQ==}
-    engines: {node: '>=16'}
-    hasBin: true
-    dependencies:
-      cpy: 10.1.0
-      meow: 12.1.0
-    dev: true
-
   /cpy@10.1.0:
     resolution: {integrity: sha512-VC2Gs20JcTyeQob6UViBLnyP0bYHkBh6EiKzot9vi2DmeGlFT9Wd7VG3NBrkNx/jYvFBeyDOMMHdHQhbtKLgHQ==}
     engines: {node: '>=16'}
@@ -4028,6 +4141,11 @@ packages:
     resolution: {integrity: sha512-463v3ZeIrcWtdgIg6vI6XUncguvr2TnGl4SzDXinkt9mSLpBJKXT3mW6xT3VQdDN11+WVs29pgvivTc4Lp8v+w==}
     engines: {node: '>=8'}
 
+  /diff@4.0.2:
+    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
+    engines: {node: '>=0.3.1'}
+    dev: true
+
   /diff@5.1.0:
     resolution: {integrity: sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==}
     engines: {node: '>=0.3.1'}
@@ -4217,6 +4335,7 @@ packages:
 
   /emoji-regex@8.0.0:
     resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+    requiresBuild: true
 
   /emoji-regex@9.2.2:
     resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
@@ -4706,6 +4825,21 @@ packages:
       - supports-color
     dev: true
 
+  /eslint-plugin-dprint@0.4.0(eslint@8.50.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-AZkzCChaFymoIZhrf6q9tUnTkw9T+b8+q6jplMwx10snnUsr+nIn5XIE0riM0al+o7HZ0KD6kmcIuuf8R7k+CA==}
+    engines: {node: ^10.12.0 || >=12.0.0}
+    peerDependencies:
+      eslint: '>=5.16.0'
+    dependencies:
+      '@typescript-eslint/experimental-utils': 3.10.1(eslint@8.50.0)(typescript@5.2.2)
+      debug: 4.3.4
+      diff: 4.0.2
+      eslint: 8.50.0
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+    dev: true
+
   /eslint-plugin-import@2.28.1(@typescript-eslint/parser@6.7.3)(eslint@8.50.0):
     resolution: {integrity: sha512-9I9hFlITvOV55alzoKBI+K9q74kv0iKMeY6av5+umsNwayt59fz692daGyjR+oStBQgx6nwR9rXldDev3Clw+A==}
     engines: {node: '>=4'}
@@ -4805,6 +4939,18 @@ packages:
       estraverse: 5.3.0
     dev: true
 
+  /eslint-utils@2.1.0:
+    resolution: {integrity: sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==}
+    engines: {node: '>=6'}
+    dependencies:
+      eslint-visitor-keys: 1.3.0
+    dev: true
+
+  /eslint-visitor-keys@1.3.0:
+    resolution: {integrity: sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==}
+    engines: {node: '>=4'}
+    dev: true
+
   /eslint-visitor-keys@3.4.3:
     resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -4932,6 +5078,21 @@ packages:
       through: 2.3.8
     dev: true
 
+  /execa@5.1.1:
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
+    dependencies:
+      cross-spawn: 7.0.3
+      get-stream: 6.0.1
+      human-signals: 2.1.0
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+    dev: true
+
   /execa@6.1.0:
     resolution: {integrity: sha512-QVWlX2e50heYJcCPG0iWtf8r0xjEYfz/OYLGDYH+IyjWezzPNxz63qNFOu0l4YftGWuizFVZHHs8PrLU5p2IDA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -5056,6 +5217,14 @@ packages:
       web-streams-polyfill: 3.2.1
     dev: true
 
+  /fetch-ponyfill@7.1.0:
+    resolution: {integrity: sha512-FhbbL55dj/qdVO3YNK7ZEkshvj3eQ7EuIGV2I6ic/2YiocvyWv+7jg2s4AyS0wdRU75s3tA8ZxI/xPigb0v5Aw==}
+    dependencies:
+      node-fetch: 2.6.11
+    transitivePeerDependencies:
+      - encoding
+    dev: true
+
   /fflate@0.7.4:
     resolution: {integrity: sha512-5u2V/CDW15QM1XbbgS+0DfPxVB+jUKhWEKuuFuHncbk3tEEqzmoXL+2KyOFuKGqOnmdIy0/davWF1CkuwtibCw==}
 
@@ -5098,15 +5267,6 @@ packages:
       - supports-color
     dev: false
 
-  /find-cache-dir@3.3.2:
-    resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==}
-    engines: {node: '>=8'}
-    dependencies:
-      commondir: 1.0.1
-      make-dir: 3.1.0
-      pkg-dir: 4.2.0
-    dev: true
-
   /find-up@4.1.0:
     resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
     engines: {node: '>=8'}
@@ -5212,15 +5372,6 @@ packages:
   /fs-constants@1.0.0:
     resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
 
-  /fs-extra@10.1.0:
-    resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==}
-    engines: {node: '>=12'}
-    dependencies:
-      graceful-fs: 4.2.11
-      jsonfile: 6.1.0
-      universalify: 2.0.0
-    dev: true
-
   /fs-extra@11.1.1:
     resolution: {integrity: sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==}
     engines: {node: '>=14.14'}
@@ -5339,7 +5490,6 @@ packages:
   /get-stream@6.0.1:
     resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
     engines: {node: '>=10'}
-    dev: false
 
   /get-symbol-description@1.0.0:
     resolution: {integrity: sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==}
@@ -5385,6 +5535,29 @@ packages:
       path-scurry: 1.7.0
     dev: true
 
+  /glob@10.3.10:
+    resolution: {integrity: sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    hasBin: true
+    dependencies:
+      foreground-child: 3.1.1
+      jackspeak: 2.3.6
+      minimatch: 9.0.1
+      minipass: 5.0.0
+      path-scurry: 1.10.1
+    dev: true
+
+  /glob@7.1.6:
+    resolution: {integrity: sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==}
+    dependencies:
+      fs.realpath: 1.0.0
+      inflight: 1.0.6
+      inherits: 2.0.4
+      minimatch: 3.1.2
+      once: 1.4.0
+      path-is-absolute: 1.0.1
+    dev: true
+
   /glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
     requiresBuild: true
@@ -5574,6 +5747,11 @@ packages:
     transitivePeerDependencies:
       - supports-color
 
+  /human-signals@2.1.0:
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
+    dev: true
+
   /human-signals@3.0.1:
     resolution: {integrity: sha512-rQLskxnM/5OCldHo+wNXbpVgDn5A17CUoKX+7Sokwaknlq7CdSnphy0W39GU8dw59XiCXmFXDg4fRuckQRKewQ==}
     engines: {node: '>=12.20.0'}
@@ -5682,6 +5860,14 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /is-arguments@1.1.1:
+    resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      has-tostringtag: 1.0.0
+    dev: true
+
   /is-array-buffer@3.0.2:
     resolution: {integrity: sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==}
     dependencies:
@@ -5763,12 +5949,20 @@ packages:
   /is-fullwidth-code-point@3.0.0:
     resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
     engines: {node: '>=8'}
+    requiresBuild: true
 
   /is-fullwidth-code-point@4.0.0:
     resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==}
     engines: {node: '>=12'}
     dev: true
 
+  /is-generator-function@1.0.10:
+    resolution: {integrity: sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      has-tostringtag: 1.0.0
+    dev: true
+
   /is-glob@4.0.3:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
     engines: {node: '>=0.10.0'}
@@ -5780,6 +5974,14 @@ packages:
     requiresBuild: true
     optional: true
 
+  /is-nan@1.3.2:
+    resolution: {integrity: sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      define-properties: 1.2.0
+    dev: true
+
   /is-negative-zero@2.0.2:
     resolution: {integrity: sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==}
     engines: {node: '>= 0.4'}
@@ -5841,6 +6043,11 @@ packages:
       call-bind: 1.0.2
     dev: true
 
+  /is-stream@2.0.1:
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
+    dev: true
+
   /is-stream@3.0.0:
     resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -5894,10 +6101,24 @@ packages:
       '@pkgjs/parseargs': 0.11.0
     dev: true
 
+  /jackspeak@2.3.6:
+    resolution: {integrity: sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==}
+    engines: {node: '>=14'}
+    dependencies:
+      '@isaacs/cliui': 8.0.2
+    optionalDependencies:
+      '@pkgjs/parseargs': 0.11.0
+    dev: true
+
   /javascript-natural-sort@0.7.1:
     resolution: {integrity: sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw==}
     dev: true
 
+  /joycon@3.1.1:
+    resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==}
+    engines: {node: '>=10'}
+    dev: true
+
   /js-base64@3.7.5:
     resolution: {integrity: sha512-3MEt5DTINKqfScXKfJFrRbxkrnk2AxPWGBL/ycjz4dK8iqiSJ06UxD8jh8xuh6p10TX4t2+7FsBYVxxQbMg+qA==}
 
@@ -6078,6 +6299,11 @@ packages:
       type-check: 0.4.0
     dev: true
 
+  /lilconfig@2.1.0:
+    resolution: {integrity: sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==}
+    engines: {node: '>=10'}
+    dev: true
+
   /lines-and-columns@1.2.4:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
     dev: true
@@ -6087,6 +6313,11 @@ packages:
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dev: true
 
+  /load-tsconfig@0.2.5:
+    resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    dev: true
+
   /local-pkg@0.4.3:
     resolution: {integrity: sha512-SFppqq5p42fe2qcZQqqEOiVRXl+WCP1MdT6k7BDEW1j++sp5fIY+/fdRQitvKgB5BrBcmrs5m/L0v2FrU5MY1g==}
     engines: {node: '>=14'}
@@ -6116,6 +6347,10 @@ packages:
     resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
     dev: true
 
+  /lodash.sortby@4.7.0:
+    resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==}
+    dev: true
+
   /lodash.throttle@4.1.1:
     resolution: {integrity: sha512-wIkUCfVKpVsWo3JSZlc+8MB5it+2AN5W8J7YVMST30UrvcQNZ1Okbj+rbVniijTWE6FGYy4XJq/rHkas8qJMLQ==}
     dev: true
@@ -6157,26 +6392,12 @@ packages:
       es5-ext: 0.10.62
     dev: true
 
-  /magic-string@0.27.0:
-    resolution: {integrity: sha512-8UnnX2PeRAPZuN12svgR9j7M1uWMovg/CEnIwIG0LFkXSJJe4PdfUGiTGl8V9bsBHFUtfVINcSyYxd7q+kx9fA==}
-    engines: {node: '>=12'}
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.4.15
-    dev: true
-
   /magic-string@0.30.0:
     resolution: {integrity: sha512-LA+31JYDJLs82r2ScLrlz1GjSgu66ZV518eyWT+S8VhyQn/JL0u9MeBOvQMGYiPk1DBiSN9DDMOcXvigJZaViQ==}
     engines: {node: '>=12'}
     dependencies:
       '@jridgewell/sourcemap-codec': 1.4.15
 
-  /magic-string@0.30.2:
-    resolution: {integrity: sha512-lNZdu7pewtq/ZvWUp9Wpf/x7WzMTsR26TWV03BRZrXFsv+BI6dy8RAiKgm1uM/kyR0rCfUcqvOlXKG66KhIGug==}
-    engines: {node: '>=12'}
-    dependencies:
-      '@jridgewell/sourcemap-codec': 1.4.15
-    dev: true
-
   /make-dir@3.1.0:
     resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
     engines: {node: '>=8'}
@@ -6220,6 +6441,27 @@ packages:
     resolution: {integrity: sha512-CkYQrPYZfWnu/DAmVCpTSX/xHpKZ80eKh2lAkyA6AJTef6bW+6JpbQZN5rofum7da+SyN1bi5ctTm+lTfcCW3g==}
     dev: true
 
+  /marked-terminal@5.2.0(marked@5.1.2):
+    resolution: {integrity: sha512-Piv6yNwAQXGFjZSaiNljyNFw7jKDdGrw70FSbtxEyldLsyeuV5ZHm/1wW++kWbrOF1VPnUgYOhB2oLL0ZpnekA==}
+    engines: {node: '>=14.13.1 || >=16.0.0'}
+    peerDependencies:
+      marked: ^1.0.0 || ^2.0.0 || ^3.0.0 || ^4.0.0 || ^5.0.0
+    dependencies:
+      ansi-escapes: 6.2.0
+      cardinal: 2.1.1
+      chalk: 5.3.0
+      cli-table3: 0.6.3
+      marked: 5.1.2
+      node-emoji: 1.11.0
+      supports-hyperlinks: 2.3.0
+    dev: true
+
+  /marked@5.1.2:
+    resolution: {integrity: sha512-ahRPGXJpjMjwSOlBoTMZAK7ATXkli5qCPxZ21TG44rx1KEo44bii4ekgTDQPNRQ4Kh7JMb9Ub1PVk1NxRSsorg==}
+    engines: {node: '>= 16'}
+    hasBin: true
+    dev: true
+
   /matcher@5.0.0:
     resolution: {integrity: sha512-s2EMBOWtXFc8dgqvoAzKJXxNHibcdJMV0gwqKUaw9E2JBJuGUK7DrNKrA6g/i+v72TT16+6sVm5mS3thaMLQUw==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -6259,18 +6501,12 @@ packages:
       timers-ext: 0.1.7
     dev: true
 
-  /meow@12.1.0:
-    resolution: {integrity: sha512-SvSqzS5ktjGoySdCwxQI16iO/ID1LtxM03QvJ4FF2H5cCtXLN7YbfKBCL9btqXSSuJ5TNG4UH6wvWtXZuvgvrw==}
-    engines: {node: '>=16.10'}
-    dev: true
-
   /merge-descriptors@1.0.1:
     resolution: {integrity: sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==}
     dev: false
 
   /merge-stream@2.0.0:
     resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
-    dev: false
 
   /merge2@1.4.1:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
@@ -6304,6 +6540,11 @@ packages:
     hasBin: true
     dev: false
 
+  /mimic-fn@2.1.0:
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
+    dev: true
+
   /mimic-fn@4.0.0:
     resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
     engines: {node: '>=12'}
@@ -6462,6 +6703,14 @@ packages:
       seq-queue: 0.0.5
       sqlstring: 2.3.3
 
+  /mz@2.7.0:
+    resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
+    dependencies:
+      any-promise: 1.3.0
+      object-assign: 4.1.1
+      thenify-all: 1.6.0
+    dev: true
+
   /named-placeholders@1.1.3:
     resolution: {integrity: sha512-eLoBxg6wE/rZkJPhU/xRX1WTpkFEwDJEN96oxFrTsqBdbT5ec295Q+CoHrL9IT0DipqKhmGcaZmwOt8OON5x1w==}
     engines: {node: '>=12.0.0'}
@@ -6513,6 +6762,12 @@ packages:
     engines: {node: '>=10.5.0'}
     dev: true
 
+  /node-emoji@1.11.0:
+    resolution: {integrity: sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==}
+    dependencies:
+      lodash: 4.17.21
+    dev: true
+
   /node-fetch@2.6.11:
     resolution: {integrity: sha512-4I6pdBY1EthSqDmJkiNk3JIT8cswwR9nfeW/cPdUagJYEQG7R95WRH74wpz7ma8Gh/9dI9FP+OU+0E4FvtA55w==}
     engines: {node: 4.x || >=6.0.0}
@@ -6595,6 +6850,13 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /npm-run-path@4.0.1:
+    resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==}
+    engines: {node: '>=8'}
+    dependencies:
+      path-key: 3.1.1
+    dev: true
+
   /npm-run-path@5.1.0:
     resolution: {integrity: sha512-sJOdmRGrY2sjNTRMbSvluQqg+8X7ZK61yvzBEIDhz4f8z1TZFYABsqjjCBd/0PUNE9M6QDgHJXQkGUEm7Q+l9Q==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -6637,6 +6899,14 @@ packages:
   /object-inspect@1.12.3:
     resolution: {integrity: sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==}
 
+  /object-is@1.1.5:
+    resolution: {integrity: sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      define-properties: 1.2.0
+    dev: true
+
   /object-keys@1.1.1:
     resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
     engines: {node: '>= 0.4'}
@@ -6694,6 +6964,13 @@ packages:
     dependencies:
       wrappy: 1.0.2
 
+  /onetime@5.1.2:
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
+    dependencies:
+      mimic-fn: 2.1.0
+    dev: true
+
   /onetime@6.0.0:
     resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}
     engines: {node: '>=12'}
@@ -6864,6 +7141,14 @@ packages:
     resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
     dev: true
 
+  /path-scurry@1.10.1:
+    resolution: {integrity: sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    dependencies:
+      lru-cache: 9.1.2
+      minipass: 5.0.0
+    dev: true
+
   /path-scurry@1.7.0:
     resolution: {integrity: sha512-UkZUeDjczjYRE495+9thsgcVgsaCPkaw80slmfVFgllxY+IO8ubTsOpFVjDPROBqJdHfVPUFRHPBV/WciOVfWg==}
     engines: {node: '>=16 || 14 >=14.17'}
@@ -6976,6 +7261,11 @@ packages:
     resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
     engines: {node: '>=8.6'}
 
+  /pirates@4.0.6:
+    resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==}
+    engines: {node: '>= 6'}
+    dev: true
+
   /pkg-conf@4.0.0:
     resolution: {integrity: sha512-7dmgi4UY4qk+4mj5Cd8v/GExPo0K+SlY+hulOSdfZ/T6jVH6//y7NtzZo5WrfhDBxuQ0jCa7fLZmNaNh7EWL/w==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -6984,13 +7274,6 @@ packages:
       load-json-file: 7.0.1
     dev: true
 
-  /pkg-dir@4.2.0:
-    resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==}
-    engines: {node: '>=8'}
-    dependencies:
-      find-up: 4.1.0
-    dev: true
-
   /pkg-types@1.0.3:
     resolution: {integrity: sha512-nN7pYi0AQqJnoLPC9eHFQ8AcyaixBUOwvqc5TDnIKCMEE6I0y8P7OKA7fPexsXGCGxQDl/cmrLAp26LhcwxZ4A==}
     dependencies:
@@ -7010,6 +7293,22 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
+  /postcss-load-config@4.0.1:
+    resolution: {integrity: sha512-vEJIc8RdiBRu3oRAI0ymerOn+7rPuMvRXslTvZUKZonDHFIczxztIyJ1urxM1x9JXEikvpWWTUUqal5j/8QgvA==}
+    engines: {node: '>= 14'}
+    peerDependencies:
+      postcss: '>=8.0.9'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      postcss:
+        optional: true
+      ts-node:
+        optional: true
+    dependencies:
+      lilconfig: 2.1.0
+      yaml: 2.3.1
+    dev: true
+
   /postcss@8.4.24:
     resolution: {integrity: sha512-M0RzbcI0sO/XJNucsGjvWU9ERWxb/ytp1w6dKtxTKgixdtQDq4rmx/g8W1hnaheq9jgwL/oyEdH5Bc4WwJKMqg==}
     engines: {node: ^10 || ^12 || >=14}
@@ -7231,6 +7530,17 @@ packages:
       picomatch: 2.3.1
     dev: true
 
+  /recast@0.23.4:
+    resolution: {integrity: sha512-qtEDqIZGVcSZCHniWwZWbRy79Dc6Wp3kT/UmDA2RJKBPg7+7k51aQBZirHmUGn5uvHf2rg8DkjizrN26k61ATw==}
+    engines: {node: '>= 4'}
+    dependencies:
+      assert: 2.1.0
+      ast-types: 0.16.1
+      esprima: 4.0.1
+      source-map: 0.6.1
+      tslib: 2.6.2
+    dev: true
+
   /rechoir@0.8.0:
     resolution: {integrity: sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==}
     engines: {node: '>= 10.13.0'}
@@ -7238,6 +7548,12 @@ packages:
       resolve: 1.22.2
     dev: true
 
+  /redeyed@2.1.1:
+    resolution: {integrity: sha512-FNpGGo1DycYAdnrKFxCMmKYgo/mILAqtRYbkdQD8Ep/Hk2PQ5+aEAEx+IU713RTDmuBaH0c8P5ZozurNu5ObRQ==}
+    dependencies:
+      esprima: 4.0.1
+    dev: true
+
   /regenerator-runtime@0.14.0:
     resolution: {integrity: sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==}
     dev: true
@@ -7347,35 +7663,6 @@ packages:
       glob: 10.2.2
     dev: true
 
-  /rollup-plugin-dts@5.3.1(rollup@3.27.2)(typescript@5.2.2):
-    resolution: {integrity: sha512-gusMi+Z4gY/JaEQeXnB0RUdU82h1kF0WYzCWgVmV4p3hWXqelaKuCvcJawfeg+EKn2T1Ie+YWF2OiN1/L8bTVg==}
-    engines: {node: '>=v14.21.3'}
-    peerDependencies:
-      rollup: ^3.0
-      typescript: ^4.1 || ^5.0
-    dependencies:
-      magic-string: 0.30.2
-      rollup: 3.27.2
-      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
-    optionalDependencies:
-      '@babel/code-frame': 7.22.13
-    dev: true
-
-  /rollup-plugin-typescript2@0.35.0(rollup@3.27.2)(typescript@5.2.2):
-    resolution: {integrity: sha512-szcIO9hPUx3PhQl91u4pfNAH2EKbtrXaES+m163xQVE5O1CC0ea6YZV/5woiDDW3CR9jF2CszPrKN+AFiND0bg==}
-    peerDependencies:
-      rollup: '>=1.26.3'
-      typescript: '>=2.4.0'
-    dependencies:
-      '@rollup/pluginutils': 4.2.1
-      find-cache-dir: 3.3.2
-      fs-extra: 10.1.0
-      rollup: 3.27.2
-      semver: 7.5.1
-      tslib: 2.5.3
-      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
-    dev: true
-
   /rollup@3.20.7:
     resolution: {integrity: sha512-P7E2zezKSLhWnTz46XxjSmInrbOCiul1yf+kJccMxT56vxjHwCbDfoLbiqFgu+WQoo9ij2PkraYaBstgB2prBA==}
     engines: {node: '>=14.18.0', npm: '>=8.0.0'}
@@ -7638,6 +7925,13 @@ packages:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
+  /source-map@0.8.0-beta.0:
+    resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==}
+    engines: {node: '>= 8'}
+    dependencies:
+      whatwg-url: 7.1.0
+    dev: true
+
   /spawn-command@0.0.2:
     resolution: {integrity: sha512-zC8zGoGkmc8J9ndvml8Xksr1Amk9qBujgbF0JAIWO7kXr43w0h/0GJNM/Vustixu+YE8N/MTrQ7N31FvHUACxQ==}
     dev: true
@@ -7833,6 +8127,11 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
+  /strip-final-newline@2.0.0:
+    resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
+    engines: {node: '>=6'}
+    dev: true
+
   /strip-final-newline@3.0.0:
     resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}
     engines: {node: '>=12'}
@@ -7862,6 +8161,20 @@ packages:
   /strnum@1.0.5:
     resolution: {integrity: sha512-J8bbNyKKXl5qYcR36TIO8W3mVGVHrmmxsd5PAItGkmyzwJvybiw2IVq5nqd0i4LSNSkB/sx9VHllbfFdr9k1JA==}
 
+  /sucrase@3.34.0:
+    resolution: {integrity: sha512-70/LQEZ07TEcxiU2dz51FKaE6hCTWC6vr7FOk3Gr0U60C3shtAN+H+BFr9XlYe5xqf3RA8nrc+VIwzCfnxuXJw==}
+    engines: {node: '>=8'}
+    hasBin: true
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.3
+      commander: 4.1.1
+      glob: 7.1.6
+      lines-and-columns: 1.2.4
+      mz: 2.7.0
+      pirates: 4.0.6
+      ts-interface-checker: 0.1.13
+    dev: true
+
   /supertap@3.0.1:
     resolution: {integrity: sha512-u1ZpIBCawJnO+0QePsEiOknOfCRq0yERxiAchT0i4li0WHNUJbf0evXXSXOcCAR4M8iMDoajXYmstm/qO81Isw==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -7893,6 +8206,14 @@ packages:
       has-flag: 4.0.0
     dev: true
 
+  /supports-hyperlinks@2.3.0:
+    resolution: {integrity: sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==}
+    engines: {node: '>=8'}
+    dependencies:
+      has-flag: 4.0.0
+      supports-color: 7.2.0
+    dev: true
+
   /supports-preserve-symlinks-flag@1.0.0:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
@@ -7961,6 +8282,19 @@ packages:
     resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==}
     dev: true
 
+  /thenify-all@1.6.0:
+    resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==}
+    engines: {node: '>=0.8'}
+    dependencies:
+      thenify: 3.3.1
+    dev: true
+
+  /thenify@3.3.1:
+    resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
+    dependencies:
+      any-promise: 1.3.0
+    dev: true
+
   /through2@4.0.2:
     resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==}
     dependencies:
@@ -8021,6 +8355,12 @@ packages:
   /tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
+  /tr46@1.0.1:
+    resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==}
+    dependencies:
+      punycode: 2.3.0
+    dev: true
+
   /tree-kill@1.2.2:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
     hasBin: true
@@ -8040,6 +8380,10 @@ packages:
       typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
     dev: true
 
+  /ts-interface-checker@0.1.13:
+    resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
+    dev: true
+
   /tsconfck@2.1.1(typescript@5.2.2):
     resolution: {integrity: sha512-ZPCkJBKASZBmBUNqGHmRhdhM8pJYDdOXp4nRgj/O0JwUwsMq50lCDRQP/M5GBNAA0elPrq4gAeu4dkaVCuKWww==}
     engines: {node: ^14.13.1 || ^16 || >=18}
@@ -8074,6 +8418,41 @@ packages:
 
   /tslib@2.6.2:
     resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==}
+
+  /tsup@7.2.0(typescript@5.2.2):
+    resolution: {integrity: sha512-vDHlczXbgUvY3rWvqFEbSqmC1L7woozbzngMqTtL2PGBODTtWlRwGDDawhvWzr5c1QjKe4OAKqJGfE1xeXUvtQ==}
+    engines: {node: '>=16.14'}
+    hasBin: true
+    peerDependencies:
+      '@swc/core': ^1
+      postcss: ^8.4.12
+      typescript: '>=4.1.0'
+    peerDependenciesMeta:
+      '@swc/core':
+        optional: true
+      postcss:
+        optional: true
+      typescript:
+        optional: true
+    dependencies:
+      bundle-require: 4.0.2(esbuild@0.18.20)
+      cac: 6.7.14
+      chokidar: 3.5.3
+      debug: 4.3.4
+      esbuild: 0.18.20
+      execa: 5.1.1
+      globby: 11.1.0
+      joycon: 3.1.1
+      postcss-load-config: 4.0.1
+      resolve-from: 5.0.0
+      rollup: 3.27.2
+      source-map: 0.8.0-beta.0
+      sucrase: 3.34.0
+      tree-kill: 1.2.2
+      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
+    transitivePeerDependencies:
+      - supports-color
+      - ts-node
     dev: true
 
   /tsutils@3.21.0(typescript@5.2.2):
@@ -8208,6 +8587,11 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /type-fest@3.13.1:
+    resolution: {integrity: sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==}
+    engines: {node: '>=14.16'}
+    dev: true
+
   /type-is@1.6.18:
     resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
     engines: {node: '>= 0.6'}
@@ -8332,6 +8716,16 @@ packages:
   /util-deprecate@1.0.2:
     resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
 
+  /util@0.12.5:
+    resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==}
+    dependencies:
+      inherits: 2.0.4
+      is-arguments: 1.1.1
+      is-generator-function: 1.0.10
+      is-typed-array: 1.1.12
+      which-typed-array: 1.1.11
+    dev: true
+
   /utils-merge@1.0.1:
     resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==}
     engines: {node: '>= 0.4.0'}
@@ -8375,6 +8769,13 @@ packages:
       builtins: 5.0.1
     dev: false
 
+  /validate-npm-package-name@5.0.0:
+    resolution: {integrity: sha512-YuKoXDAhBYxY7SfOKxHBDoSyENFeW5VvIIQp2TGQuit8gpK6MnWaQelBKxso72DoxTZfZdcP3W90LqpSkgPzLQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
+    dependencies:
+      builtins: 5.0.1
+    dev: true
+
   /vary@1.1.2:
     resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
     engines: {node: '>= 0.8'}
@@ -8522,6 +8923,10 @@ packages:
   /webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
+  /webidl-conversions@4.0.2:
+    resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==}
+    dev: true
+
   /webpod@0.0.2:
     resolution: {integrity: sha512-cSwwQIeg8v4i3p4ajHhwgR7N6VyxAf+KYSSsY6Pd3aETE+xEU4vbitz7qQkB0I321xnhDdgtxuiSfk5r/FVtjg==}
     hasBin: true
@@ -8537,6 +8942,14 @@ packages:
       tr46: 0.0.3
       webidl-conversions: 3.0.1
 
+  /whatwg-url@7.1.0:
+    resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==}
+    dependencies:
+      lodash.sortby: 4.7.0
+      tr46: 1.0.1
+      webidl-conversions: 4.0.2
+    dev: true
+
   /which-boxed-primitive@1.0.2:
     resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==}
     dependencies:
@@ -8599,6 +9012,15 @@ packages:
       string-width: 4.2.3
       strip-ansi: 6.0.1
 
+  /wrap-ansi@8.1.0:
+    resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
+    engines: {node: '>=12'}
+    dependencies:
+      ansi-styles: 6.2.1
+      string-width: 5.1.2
+      strip-ansi: 7.1.0
+    dev: true
+
   /wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
diff --git a/tsconfig.json b/tsconfig.json
index 903afcafe..0e998a3cf 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -37,8 +37,5 @@
 		"checkJs": true,
 		"allowImportingTsExtensions": true
 	},
-	"exclude": ["**/dist"],
-	"ts-node": {
-		"require": ["tsconfig-paths/register"]
-	}
+	"exclude": ["**/dist"]
 }
diff --git a/turbo.json b/turbo.json
index 45c7fc43e..b951e6975 100644
--- a/turbo.json
+++ b/turbo.json
@@ -2,7 +2,7 @@
   "$schema": "https://turbo.build/schema.json",
   "pipeline": {
     "//#lint": {
-      "inputs": ["**/*.ts", "!**/node_modules", "!**/dist"],
+      "inputs": ["**/*.ts", "!**/node_modules", "!**/dist", "!**/dist-dts"],
       "outputMode": "new-only"
     },
     "test:types": {
@@ -24,10 +24,11 @@
         "README.md",
         "../README.md",
         "tsconfig.json",
-        "tsconfig.build.json",
-        "../tsconfig.json",
-        "rollup.config.ts",
-        "rollup.dts.config.ts"
+        "tsconfig.*.json",
+        "tsup.config.ts",
+        "scripts/build.ts",
+        "scripts/fix-imports.ts",
+        "../tsconfig.json"
       ],
       "outputs": ["dist/**", "dist-dts/**"],
       "outputMode": "new-only"

From 8bec972d09bbfc32dc76aa08654b383ad23ae56a Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Sun, 15 Oct 2023 00:20:44 +0300
Subject: [PATCH 48/72] Remove eslint-plugin-dprint, as it's not working
 properly

---
 package.json   |  1 -
 pnpm-lock.yaml | 86 --------------------------------------------------
 2 files changed, 87 deletions(-)

diff --git a/package.json b/package.json
index 75bf5d632..89f2e6f17 100755
--- a/package.json
+++ b/package.json
@@ -23,7 +23,6 @@
     "drizzle-orm": "workspace:./drizzle-orm/dist",
     "drizzle-orm-old": "npm:drizzle-orm@^0.27.2",
     "eslint": "^8.50.0",
-    "eslint-plugin-dprint": "^0.4.0",
     "eslint-plugin-drizzle": "link:eslint/eslint-plugin-drizzle",
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-no-instanceof": "^1.0.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 04f784595..937f0492e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -49,9 +49,6 @@ importers:
       eslint:
         specifier: ^8.50.0
         version: 8.50.0
-      eslint-plugin-dprint:
-        specifier: ^0.4.0
-        version: 0.4.0(eslint@8.50.0)(typescript@5.2.2)
       eslint-plugin-drizzle:
         specifier: link:eslint/eslint-plugin-drizzle
         version: link:eslint/eslint-plugin-drizzle
@@ -2755,23 +2752,6 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/experimental-utils@3.10.1(eslint@8.50.0)(typescript@5.2.2):
-    resolution: {integrity: sha512-DewqIgscDzmAfd5nOGe4zm6Bl7PKtMG2Ad0KG8CUZAHlXfAKTF9Ol5PXhiMh39yRL2ChRH1cuuUGOcVyyrhQIw==}
-    engines: {node: ^10.12.0 || >=12.0.0}
-    peerDependencies:
-      eslint: '*'
-    dependencies:
-      '@types/json-schema': 7.0.13
-      '@typescript-eslint/types': 3.10.1
-      '@typescript-eslint/typescript-estree': 3.10.1(typescript@5.2.2)
-      eslint: 8.50.0
-      eslint-scope: 5.1.1
-      eslint-utils: 2.1.0
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-    dev: true
-
   /@typescript-eslint/experimental-utils@5.62.0(eslint@8.50.0)(typescript@5.2.2):
     resolution: {integrity: sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -2842,11 +2822,6 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/types@3.10.1:
-    resolution: {integrity: sha512-+3+FCUJIahE9q0lDi1WleYzjCwJs5hIsbugIgnbB+dSCYUxl8L6PwmsyOPFZde2hc1DlTo/xnkOgiTLSyAbHiQ==}
-    engines: {node: ^8.10.0 || ^10.13.0 || >=11.10.1}
-    dev: true
-
   /@typescript-eslint/types@5.62.0:
     resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -2857,28 +2832,6 @@ packages:
     engines: {node: ^16.0.0 || >=18.0.0}
     dev: true
 
-  /@typescript-eslint/typescript-estree@3.10.1(typescript@5.2.2):
-    resolution: {integrity: sha512-QbcXOuq6WYvnB3XPsZpIwztBoquEYLXh2MtwVU+kO8jgYCiv4G5xrSP/1wg4tkvrEE+esZVquIPX/dxPlePk1w==}
-    engines: {node: ^10.12.0 || >=12.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/types': 3.10.1
-      '@typescript-eslint/visitor-keys': 3.10.1
-      debug: 4.3.4
-      glob: 7.2.3
-      is-glob: 4.0.3
-      lodash: 4.17.21
-      semver: 7.5.4
-      tsutils: 3.21.0(typescript@5.2.2)
-      typescript: 5.2.2(patch_hash=wmhs4olj6eveeldp6si4l46ssq)
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /@typescript-eslint/typescript-estree@5.62.0(typescript@5.2.2):
     resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -2960,13 +2913,6 @@ packages:
       - typescript
     dev: true
 
-  /@typescript-eslint/visitor-keys@3.10.1:
-    resolution: {integrity: sha512-9JgC82AaQeglebjZMgYR5wgmfUdUc+EitGUUMW8u2nDckaeimzW+VsoLV6FoimPv2id3VQzfjwBxEMVz08ameQ==}
-    engines: {node: ^8.10.0 || ^10.13.0 || >=11.10.1}
-    dependencies:
-      eslint-visitor-keys: 1.3.0
-    dev: true
-
   /@typescript-eslint/visitor-keys@5.62.0:
     resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -4141,11 +4087,6 @@ packages:
     resolution: {integrity: sha512-463v3ZeIrcWtdgIg6vI6XUncguvr2TnGl4SzDXinkt9mSLpBJKXT3mW6xT3VQdDN11+WVs29pgvivTc4Lp8v+w==}
     engines: {node: '>=8'}
 
-  /diff@4.0.2:
-    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
-    engines: {node: '>=0.3.1'}
-    dev: true
-
   /diff@5.1.0:
     resolution: {integrity: sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==}
     engines: {node: '>=0.3.1'}
@@ -4825,21 +4766,6 @@ packages:
       - supports-color
     dev: true
 
-  /eslint-plugin-dprint@0.4.0(eslint@8.50.0)(typescript@5.2.2):
-    resolution: {integrity: sha512-AZkzCChaFymoIZhrf6q9tUnTkw9T+b8+q6jplMwx10snnUsr+nIn5XIE0riM0al+o7HZ0KD6kmcIuuf8R7k+CA==}
-    engines: {node: ^10.12.0 || >=12.0.0}
-    peerDependencies:
-      eslint: '>=5.16.0'
-    dependencies:
-      '@typescript-eslint/experimental-utils': 3.10.1(eslint@8.50.0)(typescript@5.2.2)
-      debug: 4.3.4
-      diff: 4.0.2
-      eslint: 8.50.0
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-    dev: true
-
   /eslint-plugin-import@2.28.1(@typescript-eslint/parser@6.7.3)(eslint@8.50.0):
     resolution: {integrity: sha512-9I9hFlITvOV55alzoKBI+K9q74kv0iKMeY6av5+umsNwayt59fz692daGyjR+oStBQgx6nwR9rXldDev3Clw+A==}
     engines: {node: '>=4'}
@@ -4939,18 +4865,6 @@ packages:
       estraverse: 5.3.0
     dev: true
 
-  /eslint-utils@2.1.0:
-    resolution: {integrity: sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==}
-    engines: {node: '>=6'}
-    dependencies:
-      eslint-visitor-keys: 1.3.0
-    dev: true
-
-  /eslint-visitor-keys@1.3.0:
-    resolution: {integrity: sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==}
-    engines: {node: '>=4'}
-    dev: true
-
   /eslint-visitor-keys@3.4.3:
     resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}

From 8e1c6d3a314e3faa4facdef612c3804954ed8b4a Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Sun, 15 Oct 2023 02:31:22 +0300
Subject: [PATCH 49/72] Add extension fix to ESM files

---
 drizzle-orm/scripts/fix-imports.ts | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/drizzle-orm/scripts/fix-imports.ts b/drizzle-orm/scripts/fix-imports.ts
index 5b5991dfb..f2035eeda 100755
--- a/drizzle-orm/scripts/fix-imports.ts
+++ b/drizzle-orm/scripts/fix-imports.ts
@@ -26,23 +26,23 @@ function fixImportPath(importPath: string, file: string, ext: string) {
 
 const cjsFiles = await glob('dist.new/**/*.{cjs,d.cts}');
 
-for (const file of cjsFiles) {
+await Promise.all(cjsFiles.map(async (file) => {
 	const code = parse(await fs.readFile(file, 'utf8'), { parser });
 
 	visit(code, {
 		visitImportDeclaration(path) {
 			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			return false;
+			this.traverse(path);
 		},
 		visitExportAllDeclaration(path) {
 			path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
-			return false;
+			this.traverse(path);
 		},
 		visitExportNamedDeclaration(path) {
 			if (path.value.source) {
 				path.value.source.value = fixImportPath(path.value.source.value, file, '.cjs');
 			}
-			return false;
+			this.traverse(path);
 		},
 		visitCallExpression(path) {
 			if (path.value.callee.type === 'Identifier' && path.value.callee.name === 'require') {
@@ -57,35 +57,33 @@ for (const file of cjsFiles) {
 	});
 
 	await fs.writeFile(file, print(code).code);
-}
+}));
 
 const esmFiles = await glob('dist.new/**/*.{js,d.ts}');
 
-for (const file of esmFiles) {
+await Promise.all(esmFiles.map(async (file) => {
 	const code = parse(await fs.readFile(file, 'utf8'), { parser });
 
-	// console.log(code);
-
 	visit(code, {
 		visitImportDeclaration(path) {
-			path.value.source.value = resolvePathAlias(path.value.source.value, file);
+			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
 			this.traverse(path);
 		},
 		visitExportAllDeclaration(path) {
-			path.value.source.value = resolvePathAlias(path.value.source.value, file);
+			path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
 			this.traverse(path);
 		},
 		visitExportNamedDeclaration(path) {
 			if (path.value.source) {
-				path.value.source.value = resolvePathAlias(path.value.source.value, file);
+				path.value.source.value = fixImportPath(path.value.source.value, file, '.js');
 			}
 			this.traverse(path);
 		},
 		visitTSImportType(path) {
-			path.value.argument.value = resolvePathAlias(path.value.argument.value, file);
+			path.value.argument.value = fixImportPath(path.value.argument.value, file, '.js');
 			this.traverse(path);
 		},
 	});
 
 	await fs.writeFile(file, print(code).code);
-}
+}));

From e763b299ec75950db0c907d150841fb8019b51de Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sat, 14 Oct 2023 19:33:49 -0400
Subject: [PATCH 50/72] [MySql] fixed types, addressed comments and added new
 type tests

---
 drizzle-orm/src/mysql-core/dialect.ts         |  18 +-
 .../src/mysql-core/query-builders/select.ts   |   5 +-
 .../mysql-core/query-builders/select.types.ts | 237 +++++++++++++++++-
 .../query-builders/set-operators.ts           | 204 +++++++--------
 .../query-builders/select.types.ts            |   2 +-
 .../query-builders/set-operators.ts           |   4 +-
 drizzle-orm/type-tests/mysql/set-operators.ts | 130 +++++++---
 7 files changed, 441 insertions(+), 159 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index ac82e8ffa..138c78a3f 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -19,12 +19,16 @@ import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import { View, ViewBaseConfig } from '~/view.ts';
-import { DrizzleError } from '../index.ts';
+import { DrizzleError, Name } from '../index.ts';
 import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
-import type { MySqlSelectConfig, MySqlSelectJoinConfig, SelectedFieldsOrdered } from './query-builders/select.types.ts';
-import type { MySqlSetOperatorConfig } from './query-builders/set-operators.ts';
+import type {
+	MySqlSelectConfig,
+	MySqlSelectJoinConfig,
+	MySqlSetOperationConfig,
+	SelectedFieldsOrdered,
+} from './query-builders/select.types.ts';
 import type { MySqlUpdateConfig } from './query-builders/update.ts';
 import type { MySqlSession } from './session.ts';
 import { MySqlTable } from './table.ts';
@@ -343,25 +347,25 @@ export class MySqlDialect {
 		limit,
 		orderBy,
 		offset,
-	}: MySqlSetOperatorConfig): SQL {
+	}: MySqlSetOperationConfig): SQL {
 		const leftChunk = sql`(${leftSelect.getSQL()}) `;
 		const rightChunk = sql`(${rightSelect.getSQL()})`;
 
 		let orderBySql;
 		if (orderBy && orderBy.length > 0) {
-			const orderByValues: SQL<unknown>[] = [];
+			const orderByValues: (SQL<unknown> | Name)[] = [];
 
 			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
 			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
 			for (const orderByUnit of orderBy) {
 				if (is(orderByUnit, MySqlColumn)) {
-					orderByValues.push(sql.raw(orderByUnit.name));
+					orderByValues.push(sql.identifier(orderByUnit.name));
 				} else if (is(orderByUnit, SQL)) {
 					for (let i = 0; i < orderByUnit.queryChunks.length; i++) {
 						const chunk = orderByUnit.queryChunks[i];
 
 						if (is(chunk, MySqlColumn)) {
-							orderByUnit.queryChunks[i] = sql.raw(chunk.name);
+							orderByUnit.queryChunks[i] = sql.identifier(chunk.name);
 						}
 					}
 
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.ts b/drizzle-orm/src/mysql-core/query-builders/select.ts
index 640575289..0d499881c 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.ts
@@ -120,9 +120,10 @@ export abstract class MySqlSelectQueryBuilderBase<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends MySqlSetOperatorBuilder<
+	THKT,
 	TTableName,
 	TSelection,
 	TSelectMode,
@@ -401,7 +402,7 @@ export interface MySqlSelectBase<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
 	MySqlSelectQueryBuilderBase<
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index b8e295f32..3492d3607 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -6,6 +6,7 @@ import type {
 	SelectedFieldsFlat as SelectedFieldsFlatBase,
 	SelectedFieldsOrdered as SelectedFieldsOrderedBase,
 } from '~/operations.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	AppendToNullabilityMap,
 	AppendToResult,
@@ -16,14 +17,17 @@ import type {
 	MapColumnsToTableAlias,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import type { Placeholder, SQL } from '~/sql/index.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
-import type { Assume } from '~/utils.ts';
+import type { Assume, ValidateShape } from '~/utils.ts';
 import type { ColumnsSelection, View } from '~/view.ts';
-import type { PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
+import type { MySqlDialect } from '../dialect.ts';
+import type { MySqlSession, PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
 import type { MySqlSelectBase, MySqlSelectQueryBuilderBase } from './select.ts';
+import type { MySqlSetOperatorBase, MySqlSetOperatorBuilder } from './set-operators.ts';
 
 export interface MySqlSelectJoinConfig {
 	on: SQL | undefined;
@@ -81,13 +85,14 @@ export type MySqlJoin<
 				T['_']['selection'],
 				TJoinedName,
 				TJoinedTable extends MySqlTable ? TJoinedTable['_']['columns']
-					: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
 					: never,
 				T['_']['selectMode']
 			>,
 			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
+			T['_']['preparedQueryHKT'],
 			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
-			TDynamic,
+			T['_']['dynamic'],
 			T['_']['excludedMethods']
 		>,
 		TDynamic,
@@ -144,6 +149,7 @@ export type MySqlSelectKind<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability>,
 	TDynamic extends boolean,
 	TExcludedMethods extends string,
@@ -153,6 +159,7 @@ export type MySqlSelectKind<
 	tableName: TTableName;
 	selection: TSelection;
 	selectMode: TSelectMode;
+	preparedQueryHKT: TPreparedQueryHKT;
 	nullabilityMap: TNullabilityMap;
 	dynamic: TDynamic;
 	excludedMethods: TExcludedMethods;
@@ -170,7 +177,7 @@ export interface MySqlSelectQueryBuilderHKT extends MySqlSelectHKTBase {
 		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
 		this['dynamic'],
 		this['excludedMethods'],
-		this['result'],
+		Assume<this['result'], any[]>,
 		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
@@ -184,7 +191,7 @@ export interface MySqlSelectHKT extends MySqlSelectHKTBase {
 		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
 		this['dynamic'],
 		this['excludedMethods'],
-		this['result'],
+		Assume<this['result'], any[]>,
 		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
@@ -194,14 +201,16 @@ export type MySqlSelectWithout<
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T : Omit<
-	MySqlSelectKind<
-		T['_']['hkt'],
+	MySqlSelectBase<
 		T['_']['tableName'],
 		T['_']['selection'],
 		T['_']['selectMode'],
+		T['_']['preparedQueryHKT'],
 		T['_']['nullabilityMap'],
 		TDynamic,
-		T['_']['excludedMethods'] | K
+		T['_']['excludedMethods'] | K,
+		T['_']['result'],
+		T['_']['selectedFields']
 	>,
 	T['_']['excludedMethods'] | K
 >;
@@ -220,6 +229,7 @@ export type MySqlSelectDynamic<T extends AnyMySqlSelectQueryBuilder> = MySqlSele
 	T['_']['tableName'],
 	T['_']['selection'],
 	T['_']['selectMode'],
+	T['_']['preparedQueryHKT'],
 	T['_']['nullabilityMap'],
 	true,
 	never,
@@ -243,7 +253,7 @@ export type MySqlSelectQueryBuilder<
 	TSelectMode extends SelectMode = SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-	TResult = unknown,
+	TResult extends any[] = unknown[],
 	TSelectedFields extends ColumnsSelection = Record<string, any>,
 > = MySqlSelectQueryBuilderBase<
 	THKT,
@@ -258,7 +268,7 @@ export type MySqlSelectQueryBuilder<
 	TSelectedFields
 >;
 
-export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any, any>;
 
 export type MySqlSelect<
 	TTableName extends string | undefined = string | undefined,
@@ -268,3 +278,208 @@ export type MySqlSelect<
 > = MySqlSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TNullabilityMap, true, never>;
 
 export type AnyMySqlSelect = MySqlSelectBase<any, any, any, any, any, any, any, any>;
+
+export type MySqlSetOperatorBaseWithResult<T extends any[]> = MySqlSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	T,
+	any
+>;
+
+export type SetOperatorRightSelect<
+	TValue extends MySqlSetOperatorBaseWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
+	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
+			TValueObj,
+			TResult[number],
+			TypedQueryBuilder<any, TValueResult>
+		>
+	: never
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly MySqlSetOperatorBaseWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
+		? TValueResult extends Array<infer TValueObj>
+			? Rest extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, any, any>[] ? [
+					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
+					...SetOperatorRestSelect<Rest, TResult>,
+				]
+			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+		: never
+	: never
+	: TValue;
+
+export interface MySqlSetOperationConfig {
+	fields: Record<string, unknown>;
+	operator: SetOperator;
+	isAll: boolean;
+	leftSelect: AnyMySqlSetOperatorBase;
+	rightSelect: TypedQueryBuilder<any, any[]>;
+	limit?: number | Placeholder;
+	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+	offset?: number | Placeholder;
+}
+
+export interface MySqlSetOperatorInterface<
+	THKT extends MySqlSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends
+	TypedQueryBuilder<
+		TSelectedFields,
+		TResult
+	>
+{
+	_: {
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+	getSelectedFields: () => TSelectedFields;
+	getSetOperatorConfig: () => {
+		session: MySqlSession<any, any, any, any> | undefined;
+		dialect: MySqlDialect;
+		joinsNotNullableMap: Record<string, boolean>;
+		fields: Record<string, unknown>;
+	};
+}
+
+export type AnyMySqlSetOperatorBase = MySqlSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type MySqlCreateSetOperatorFn = <
+	THKT extends MySqlSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends MySqlSetOperatorBaseWithResult<TResult>,
+	TRest extends MySqlSetOperatorBaseWithResult<TResult>[],
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+>(
+	leftSelect: MySqlSetOperatorInterface<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TResult>,
+	...restSelects: SetOperatorRestSelect<TRest, TResult>
+) => MySqlSetOperatorBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap,
+	TDynamic,
+	TExcludedMethods,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnyMySqlSetOperator = MySqlSetOperatorBase<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type MySqlSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MySqlSetOperatorBase<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap, true, never>;
+
+export type AnyMySqlSetOperatorBuilder = MySqlSetOperatorBuilder<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type MySqlSetOperatorWithout<
+	T extends AnyMySqlSetOperator,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		MySqlSetOperatorBase<
+			T['_']['tableName'],
+			T['_']['selection'],
+			T['_']['selectMode'],
+			T['_']['nullabilityMap'],
+			T['_']['preparedQueryHKT'],
+			TDynamic,
+			T['_']['excludedMethods'] | K,
+			T['_']['result'],
+			T['_']['selectedFields']
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type MySqlSetOperatorDynamic<T extends AnyMySqlSetOperatorBuilder> = MySqlSetOperatorBase<
+	T['_']['tableName'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['preparedQueryHKT'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index fb7916b47..160b55123 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -9,7 +9,6 @@ import {
 	SelectionProxyHandler,
 	type SQL,
 	Subquery,
-	type ValidateShape,
 	type ValueOrArray,
 } from '~/index.ts';
 import type {
@@ -24,13 +23,22 @@ import type {
 	JoinNullability,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import type { MySqlColumn } from '../columns/common.ts';
 import type { MySqlDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
-
-type SetOperator = 'union' | 'intersect' | 'except';
+import type {
+	MySqlCreateSetOperatorFn,
+	MySqlSelectHKTBase,
+	MySqlSetOperationConfig,
+	MySqlSetOperatorBaseWithResult,
+	MySqlSetOperatorDynamic,
+	MySqlSetOperatorInterface,
+	MySqlSetOperatorWithout,
+	SetOperatorRightSelect,
+} from './select.types.ts';
 
 const getMySqlSetOperators = () => {
 	return {
@@ -45,59 +53,8 @@ const getMySqlSetOperators = () => {
 
 type MySqlSetOperators = ReturnType<typeof getMySqlSetOperators>;
 
-type SetOperatorRightSelect<
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-> = TValue extends MySqlSetOperatorBuilder<any, infer TSel, infer TMode, any, infer TNull> ? ValidateShape<
-		SelectResult<TSel, TMode, TNull>,
-		SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-		TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
-	>
-	: TValue;
-
-type SetOperatorRestSelect<
-	TValue extends readonly TypedQueryBuilder<any, any[]>[],
-	Valid,
-> = TValue extends [infer First, ...infer Rest]
-	? First extends MySqlSetOperatorBuilder<any, infer TSel, infer TMode, any, infer TNull>
-		? Rest extends TypedQueryBuilder<any, any[]>[] ? [
-				ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue[0]>,
-				...SetOperatorRestSelect<Rest, Valid>,
-			]
-		: ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue>
-	: never[]
-	: TValue;
-
-export interface MySqlSetOperatorConfig {
-	fields: Record<string, unknown>;
-	operator: SetOperator;
-	isAll: boolean;
-	leftSelect: MySqlSetOperatorBuilder<any, any, any, any, any, any, any, any, any>;
-	rightSelect: TypedQueryBuilder<any, any[]>;
-	limit?: number | Placeholder;
-	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
-	offset?: number | Placeholder;
-}
-
-export interface MySqlSetOperatorBuilder<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TDynamic extends boolean = false,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult> {}
-
 export abstract class MySqlSetOperatorBuilder<
+	THKT extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -106,11 +63,24 @@ export abstract class MySqlSetOperatorBuilder<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'MySqlSetOperatorBuilder';
 
+	abstract override readonly _: {
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+
 	protected abstract joinsNotNullableMap: Record<string, boolean>;
 	protected abstract config: {
 		fields: Record<string, unknown>;
@@ -132,14 +102,14 @@ export abstract class MySqlSetOperatorBuilder<
 		};
 	}
 
-	private setOperator(
+	private createSetOperator(
 		type: SetOperator,
 		isAll: boolean,
-	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+	): <TValue extends MySqlSetOperatorBaseWithResult<TResult>>(
 		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	) => MySqlSetOperator<
+			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => MySqlSetOperatorBase<
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -152,24 +122,39 @@ export abstract class MySqlSetOperatorBuilder<
 	> {
 		return (rightSelect) => {
 			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
-			return new MySqlSetOperator(type, isAll, this, rightSelectOrig);
+			return new MySqlSetOperatorBase(type, isAll, this as any, rightSelectOrig as any);
 		};
 	}
 
-	union = this.setOperator('union', false);
+	union = this.createSetOperator('union', false);
 
-	unionAll = this.setOperator('union', true);
+	unionAll = this.createSetOperator('union', true);
 
-	intersect = this.setOperator('intersect', false);
+	intersect = this.createSetOperator('intersect', false);
 
-	intersectAll = this.setOperator('intersect', true);
+	intersectAll = this.createSetOperator('intersect', true);
 
-	except = this.setOperator('except', false);
+	except = this.createSetOperator('except', false);
 
-	exceptAll = this.setOperator('except', true);
+	exceptAll = this.createSetOperator('except', true);
 }
 
-export class MySqlSetOperator<
+export interface MySqlSetOperatorBase<
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TDynamic extends boolean = false,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult> {}
+
+export class MySqlSetOperatorBase<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -181,6 +166,7 @@ export class MySqlSetOperator<
 	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends MySqlSetOperatorBuilder<
+	MySqlSelectHKTBase,
 	TTableName,
 	TSelection,
 	TSelectMode,
@@ -193,8 +179,21 @@ export class MySqlSetOperator<
 > {
 	static readonly [entityKind]: string = 'MySqlSetOperator';
 
+	readonly _: {
+		readonly hkt: MySqlSelectHKTBase;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly preparedQueryHKT: TPreparedQueryHKT;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+
 	protected joinsNotNullableMap: Record<string, boolean>;
-	protected config: MySqlSetOperatorConfig;
+	protected config: MySqlSetOperationConfig;
 	/* @internal */
 	readonly session: MySqlSession | undefined;
 	protected dialect: MySqlDialect;
@@ -202,7 +201,8 @@ export class MySqlSetOperator<
 	constructor(
 		operator: SetOperator,
 		isAll: boolean,
-		leftSelect: MySqlSetOperatorBuilder<
+		leftSelect: MySqlSetOperatorInterface<
+			MySqlSelectHKTBase,
 			TTableName,
 			TSelection,
 			TSelectMode,
@@ -213,7 +213,7 @@ export class MySqlSetOperator<
 			TResult,
 			TSelectedFields
 		>,
-		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+		rightSelect: TypedQueryBuilder<any, TResult>,
 	) {
 		super();
 
@@ -248,7 +248,7 @@ export class MySqlSetOperator<
 		...columns:
 			| [(aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
 			| (MySqlColumn | SQL | SQL.Aliased)[]
-	) {
+	): MySqlSetOperatorWithout<this, TDynamic, 'orderBy'> {
 		if (typeof columns[0] === 'function') {
 			const orderBy = columns[0](
 				new Proxy(
@@ -260,17 +260,17 @@ export class MySqlSetOperator<
 		} else {
 			this.config.orderBy = columns as (MySqlColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
-	limit(limit: number) {
+	limit(limit: number): MySqlSetOperatorWithout<this, TDynamic, 'limit'> {
 		this.config.limit = limit;
-		return this;
+		return this as any;
 	}
 
-	offset(offset: number | Placeholder) {
+	offset(offset: number | Placeholder): MySqlSetOperatorWithout<this, TDynamic, 'offset'> {
 		this.config.offset = offset;
-		return this;
+		return this as any;
 	}
 
 	/** @internal */
@@ -325,51 +325,39 @@ export class MySqlSetOperator<
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
 		) as SubqueryWithSelection<TSelectedFields, TAlias>;
 	}
+
+	$dynamic(): MySqlSetOperatorDynamic<this> {
+		return this as any;
+	}
 }
 
-applyMixins(MySqlSetOperatorBuilder, [QueryPromise]);
+applyMixins(MySqlSetOperatorBase, [QueryPromise]);
 
-function setOperator(type: SetOperator, isAll: boolean): <
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: MySqlSetOperatorBuilder<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap,
-		any,
-		any
-	>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-) => MySqlSetOperator<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap> {
+function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		if (restSelects.length === 0) {
-			return new MySqlSetOperator(type, isAll, leftSelect, rightSelect);
+			return new MySqlSetOperatorBase(type, isAll, leftSelect, rightSelect as any);
 		}
 
 		const [select, ...rest] = restSelects;
 		if (!select) throw new Error('Cannot pass undefined values to any set operator');
 
-		return setOperator(type, isAll)(new MySqlSetOperator(type, isAll, leftSelect, rightSelect), select, ...rest);
+		return createSetOperator(type, isAll)(
+			new MySqlSetOperatorBase(type, isAll, leftSelect, rightSelect as any),
+			select as any,
+			...rest,
+		);
 	};
 }
 
-export const union = setOperator('union', false);
+export const union = createSetOperator('union', false);
 
-export const unionAll = setOperator('union', true);
+export const unionAll = createSetOperator('union', true);
 
-export const intersect = setOperator('intersect', false);
+export const intersect = createSetOperator('intersect', false);
 
-export const intersectAll = setOperator('intersect', true);
+export const intersectAll = createSetOperator('intersect', true);
 
-export const except = setOperator('except', false);
+export const except = createSetOperator('except', false);
 
-export const exceptAll = setOperator('except', true);
+export const exceptAll = createSetOperator('except', true);
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index a53b9abab..9f8634be0 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -414,7 +414,7 @@ export type AnySQLiteSetOperatorBase = SQLiteSetOperatorInterface<
 	any
 >;
 
-export type CreateSetOperatorFn = <
+export type SQLiteCreateSetOperatorFn = <
 	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index daa353e84..930a13abf 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -25,8 +25,8 @@ import type { SQLiteColumn } from '../columns/common.ts';
 import type { SQLiteDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
 import type {
-	CreateSetOperatorFn,
 	SetOperatorRightSelect,
+	SQLiteCreateSetOperatorFn,
 	SQLiteSelectHKTBase,
 	SQLiteSetOperationConfig,
 	SQLiteSetOperatorBaseWithResult,
@@ -355,7 +355,7 @@ export class SQLiteSetOperatorBase<
 
 applyMixins(SQLiteSetOperatorBase, [QueryPromise]);
 
-function createSetOperator(type: SetOperator, isAll: boolean): CreateSetOperatorFn {
+function createSetOperator(type: SetOperator, isAll: boolean): SQLiteCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		if (restSelects.length === 0) {
 			return new SQLiteSetOperatorBase(type, isAll, leftSelect, rightSelect as any);
diff --git a/drizzle-orm/type-tests/mysql/set-operators.ts b/drizzle-orm/type-tests/mysql/set-operators.ts
index bc869bf88..a936868ed 100644
--- a/drizzle-orm/type-tests/mysql/set-operators.ts
+++ b/drizzle-orm/type-tests/mysql/set-operators.ts
@@ -1,6 +1,14 @@
 import { type Equal, Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
-import { except, exceptAll, intersect, intersectAll, union, unionAll } from '~/mysql-core/index.ts';
+import {
+	except,
+	exceptAll,
+	intersect,
+	intersectAll,
+	type MySqlSetOperator,
+	union,
+	unionAll,
+} from '~/mysql-core/index.ts';
 import { desc, sql } from '~/sql/index.ts';
 import { db } from './db.ts';
 import { cities, classes, newYorkers, users } from './tables.ts';
@@ -17,15 +25,15 @@ const unionTest = await db
 Expect<Equal<{ id: number }[], typeof unionTest>>;
 
 const unionAllTest = await db
-	.select({ id: users.id, text: users.text })
+	.select({ id: users.id, age: users.age1 })
 	.from(users)
 	.unionAll(
-		db.select({ id: users.id, text: users.text })
+		db.select({ id: users.id, age: users.age1 })
 			.from(users)
 			.leftJoin(cities, eq(users.id, cities.id)),
 	);
 
-Expect<Equal<{ id: number; text: string | null }[], typeof unionAllTest>>;
+Expect<Equal<{ id: number; age: number }[], typeof unionAllTest>>;
 
 const intersectTest = await db
 	.select({ id: users.id, homeCity: users.homeCity })
@@ -46,7 +54,7 @@ Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
 const intersectAllTest = await db
 	.select({ id: users.id, homeCity: users.class })
 	.from(users)
-	.intersectAll(
+	.intersect(
 		db
 			.select({ id: users.id, homeCity: users.class })
 			.from(users)
@@ -69,7 +77,7 @@ Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
 const exceptAllTest = await db
 	.select({ id: users.id, homeCity: users.class })
 	.from(users)
-	.exceptAll(
+	.except(
 		db
 			.select({ id: users.id, homeCity: sql<'A' | 'C'>`${users.class}` })
 			.from(users),
@@ -112,10 +120,16 @@ const intersect2Test = await intersect(
 
 Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
 
-const intersectAll2Test = await intersectAll(
-	db.select({
-		id: cities.id,
-	}).from(cities),
+const intersectAll2Test = await intersect(
+	union(
+		db.select({
+			id: cities.id,
+		}).from(cities),
+		db.select({
+			id: cities.id,
+		})
+			.from(cities).where(sql``),
+	),
 	db.select({
 		id: cities.id,
 	})
@@ -136,47 +150,97 @@ const except2Test = await except(
 
 Expect<Equal<{ userId: number }[], typeof except2Test>>;
 
-const exceptAll2Test = await exceptAll(
+const exceptAll2Test = await except(
 	db.select({
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
 	})
-		.from(newYorkers),
+		.from(newYorkers).where(sql``),
 	db.select({
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
-	}).from(newYorkers),
+	}).from(newYorkers).leftJoin(newYorkers, sql``),
 );
 
 Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
 
+const unionfull = await union(db.select().from(users), db.select().from(users)).orderBy(sql``).limit(1).offset(2);
+
+Expect<
+	Equal<{
+		id: number;
+		text: string | null;
+		homeCity: number;
+		currentCity: number | null;
+		serialNullable: number;
+		serialNotNull: number;
+		class: 'A' | 'C';
+		subClass: 'B' | 'D' | null;
+		age1: number;
+		createdAt: Date;
+		enumCol: 'a' | 'b' | 'c';
+	}[], typeof unionfull>
+>;
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+union(db.select().from(users), db.select().from(users))
+	.offset(1)
+	// @ts-expect-error - method was already called
+	.offset(2);
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
 {
-	const query = db
-		.select()
-		.from(users)
-		.union(
-			db.select()
-				.from(users),
-		)
-		.prepare()
-		.iterator();
-	for await (const row of query) {
-		Expect<Equal<typeof users.$inferSelect, typeof row>>();
+	function dynamic<T extends MySqlSetOperator>(qb: T) {
+		return qb.orderBy(sql``).limit(1).offset(2);
 	}
+
+	const qb = union(db.select().from(users), db.select().from(users)).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
 }
 
+await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	.intersect(({ intersect }) =>
+		intersect(
+			db
+				.select()
+				.from(users),
+			db
+				.select()
+				.from(users),
+		)
+	);
+
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type
 // @ts-expect-error
 db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
 
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes).where(sql``));
+
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type
 // @ts-expect-error
 db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
 
 union(
-	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
@@ -184,6 +248,16 @@ union(
 	db.select().from(cities),
 );
 
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``).limit(3).$dynamic(),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+);
+
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -204,18 +278,18 @@ union(
 	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
+	db.select({ id: newYorkers.userId }).from(newYorkers),
 	db.select({ id: cities.id }).from(cities),
 );
 
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities).where(sql``),
 	db.select({ id: sql<number>`${cities.id}` }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
 	// @ts-expect-error
-	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities).where(sql``),
 );

From f04127c1949edb8b539a73e727cd8165a6e68f9f Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Sun, 15 Oct 2023 02:44:17 +0300
Subject: [PATCH 51/72] Add attw to feature branch pipeline

---
 .github/workflows/release-feature-branch.yaml | 22 ++++++++++++++++---
 .github/workflows/release-latest.yaml         |  2 +-
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/release-feature-branch.yaml b/.github/workflows/release-feature-branch.yaml
index 2f5f85b4f..bacbec573 100644
--- a/.github/workflows/release-feature-branch.yaml
+++ b/.github/workflows/release-feature-branch.yaml
@@ -122,6 +122,24 @@ jobs:
             pnpm test --filter ${{ matrix.package }}
           fi
 
+      - name: Pack
+        if: steps.checks.outputs.has_new_release == 'true'
+        working-directory: ${{ matrix.package }}
+        shell: bash
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
+        run: |
+          npm run pack
+  
+      - name: Run @arethetypeswrong/cli
+        if: steps.checks.outputs.has_new_release == 'true'
+        working-directory: ${{ matrix.package }}
+        shell: bash
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_ACCESS_TOKEN }}
+        run: |
+          pnpm attw package.tgz
+
       - name: Publish
         if: github.event_name == 'push' && steps.checks.outputs.has_new_release == 'true'
         run: |
@@ -130,14 +148,12 @@ jobs:
 
           echo "Publishing ${{ matrix.package }}@$tag using version $version"
           (cd dist && npm version $version)
-          npm run pack
-          npx attw package.tgz
           npm run publish -- --tag $tag
 
           echo "npm: \`${{ matrix.package }}@$tag | ${{ matrix.package }}@$version\`" >> $GITHUB_STEP_SUMMARY
 
           # Post release message to Discord
-          curl -X POST -H "Content-Type: application/json" -d "{\"embeds\": [{\"title\": \"New \`${{ matrix.package }}\` release! 🎉\", \"url\": \"https://www.npmjs.com/package/${{ matrix.package }}/v/$version\", \"color\": \"12907856\", \"fields\": [{\"name\": \"Version\", \"value\": \"\`$version\`\"}, {\"name\": \"Tag\", \"value\": \"\`$tag\`\"}]}]}" ${{ secrets.DISCORD_DEV_RELEASE_WEBHOOK_URL }}
+          # curl -X POST -H "Content-Type: application/json" -d "{\"embeds\": [{\"title\": \"New \`${{ matrix.package }}\` release! 🎉\", \"url\": \"https://www.npmjs.com/package/${{ matrix.package }}/v/$version\", \"color\": \"12907856\", \"fields\": [{\"name\": \"Version\", \"value\": \"\`$version\`\"}, {\"name\": \"Tag\", \"value\": \"\`$tag\`\"}]}]}" ${{ secrets.DISCORD_DEV_RELEASE_WEBHOOK_URL }}
         working-directory: ${{ matrix.package }}
         shell: bash
         env:
diff --git a/.github/workflows/release-latest.yaml b/.github/workflows/release-latest.yaml
index ff21eb1fd..3153adb32 100644
--- a/.github/workflows/release-latest.yaml
+++ b/.github/workflows/release-latest.yaml
@@ -132,7 +132,7 @@ jobs:
         run: |
           npm run pack
 
-      - name: Running @arethetypeswrong/cli
+      - name: Run @arethetypeswrong/cli
         if: steps.checks.outputs.has_new_release == 'true'
         working-directory: ${{ matrix.package }}
         shell: bash

From 92ad044377f2b226bcdda95fbb523579a3e30961 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Sun, 15 Oct 2023 03:16:30 +0300
Subject: [PATCH 52/72] Fix build script

---
 .github/workflows/release-feature-branch.yaml |  2 +-
 drizzle-orm/scripts/build.ts                  | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/release-feature-branch.yaml b/.github/workflows/release-feature-branch.yaml
index bacbec573..8bb121a1c 100644
--- a/.github/workflows/release-feature-branch.yaml
+++ b/.github/workflows/release-feature-branch.yaml
@@ -86,6 +86,7 @@ jobs:
         run: |
           old_version="$(jq -r .version package.json)"
           version="$old_version-$(git rev-parse --short HEAD)"
+          (cd dist && npm version $version)
           tag="${{ github.ref_name }}"
           is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
 
@@ -147,7 +148,6 @@ jobs:
           version="${{ steps.checks.outputs.version }}"
 
           echo "Publishing ${{ matrix.package }}@$tag using version $version"
-          (cd dist && npm version $version)
           npm run publish -- --tag $tag
 
           echo "npm: \`${{ matrix.package }}@$tag | ${{ matrix.package }}@$version\`" >> $GITHUB_STEP_SUMMARY
diff --git a/drizzle-orm/scripts/build.ts b/drizzle-orm/scripts/build.ts
index 35057f941..058a719b9 100755
--- a/drizzle-orm/scripts/build.ts
+++ b/drizzle-orm/scripts/build.ts
@@ -51,11 +51,6 @@ await fs.remove('dist.new');
 await Promise.all([
 	(async () => {
 		await $`tsup`;
-
-		await Promise.all([
-			$`tsup src/version.ts --no-config --dts --format esm --outDir dist.new`,
-			$`tsup src/version.ts --no-config --dts --format cjs --outDir dist.new`,
-		]);
 	})(),
 	(async () => {
 		await $`tsc -p tsconfig.dts.json`;
@@ -68,6 +63,11 @@ await Promise.all([
 	})(),
 ]);
 
+await Promise.all([
+	$`tsup src/version.ts --no-config --dts --format esm --outDir dist.new`,
+	$`tsup src/version.ts --no-config --dts --format cjs --outDir dist.new`,
+]);
+
 await $`scripts/fix-imports.ts`;
 
 await fs.copy('../README.md', 'dist.new/README.md');

From cf6274ff7b9e3dd6d4ba682b85487c90f9609272 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Sun, 15 Oct 2023 03:18:52 +0300
Subject: [PATCH 53/72] Fix setting version

---
 .github/workflows/release-feature-branch.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release-feature-branch.yaml b/.github/workflows/release-feature-branch.yaml
index 8bb121a1c..3126e994a 100644
--- a/.github/workflows/release-feature-branch.yaml
+++ b/.github/workflows/release-feature-branch.yaml
@@ -86,7 +86,7 @@ jobs:
         run: |
           old_version="$(jq -r .version package.json)"
           version="$old_version-$(git rev-parse --short HEAD)"
-          (cd dist && npm version $version)
+          npm version $version
           tag="${{ github.ref_name }}"
           is_version_published="$(npm view ${{ matrix.package }} versions --json | jq -r '.[] | select(. == "'$version'") | . == "'$version'"')"
 

From 0b1d5ae8848b0fe03f27a8c1b3e926339300be08 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sat, 14 Oct 2023 21:17:46 -0400
Subject: [PATCH 54/72] [Pg] fixed types, addressed comments and added new type
 tests, fixed eslint errors

---
 drizzle-orm/src/mysql-core/dialect.ts         |   2 +-
 .../mysql-core/query-builders/select.types.ts |  31 +--
 .../query-builders/set-operators.ts           |   7 +-
 drizzle-orm/src/pg-core/dialect.ts            |   7 +-
 .../src/pg-core/query-builders/select.ts      |   4 +-
 .../pg-core/query-builders/select.types.ts    | 210 +++++++++++++++++-
 .../pg-core/query-builders/set-operators.ts   | 159 ++++++-------
 drizzle-orm/src/sqlite-core/dialect.ts        |   2 +-
 .../query-builders/select.types.ts            |  32 +--
 .../query-builders/set-operators.ts           |  13 +-
 drizzle-orm/type-tests/mysql/set-operators.ts |  15 +-
 drizzle-orm/type-tests/pg/set-operators.ts    | 104 +++++++--
 .../type-tests/sqlite/set-operators.ts        |  13 +-
 13 files changed, 425 insertions(+), 174 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index 138c78a3f..fe936d97f 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -19,7 +19,7 @@ import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import { View, ViewBaseConfig } from '~/view.ts';
-import { DrizzleError, Name } from '../index.ts';
+import { DrizzleError, type Name } from '../index.ts';
 import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index 3492d3607..e70475dd4 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -24,8 +24,7 @@ import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import type { Assume, ValidateShape } from '~/utils.ts';
 import type { ColumnsSelection, View } from '~/view.ts';
-import type { MySqlDialect } from '../dialect.ts';
-import type { MySqlSession, PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
+import type { PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
 import type { MySqlSelectBase, MySqlSelectQueryBuilderBase } from './select.ts';
 import type { MySqlSetOperatorBase, MySqlSetOperatorBuilder } from './set-operators.ts';
 
@@ -343,9 +342,20 @@ export interface MySqlSetOperatorInterface<
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	TypedQueryBuilder<
-		TSelectedFields,
-		TResult
+	Omit<
+		MySqlSetOperatorBuilder<
+			THKT,
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TPreparedQueryHKT,
+			TNullabilityMap,
+			TDynamic,
+			TExcludedMethods,
+			TResult,
+			TSelectedFields
+		>,
+		'joinsNotNullableMap' | 'session' | 'dialect' | 'createSetOperator'
 	>
 {
 	_: {
@@ -360,13 +370,6 @@ export interface MySqlSetOperatorInterface<
 		readonly result: TResult;
 		readonly selectedFields: TSelectedFields;
 	};
-	getSelectedFields: () => TSelectedFields;
-	getSetOperatorConfig: () => {
-		session: MySqlSession<any, any, any, any> | undefined;
-		dialect: MySqlDialect;
-		joinsNotNullableMap: Record<string, boolean>;
-		fields: Record<string, unknown>;
-	};
 }
 
 export type AnyMySqlSetOperatorBase = MySqlSetOperatorInterface<
@@ -415,8 +418,8 @@ export type MySqlCreateSetOperatorFn = <
 	TSelectMode,
 	TPreparedQueryHKT,
 	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
+	false,
+	never,
 	TResult,
 	TSelectedFields
 >;
diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 160b55123..7b1b742ce 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -115,8 +115,8 @@ export abstract class MySqlSetOperatorBuilder<
 		TSelectMode,
 		TPreparedQueryHKT,
 		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
+		false,
+		never,
 		TResult,
 		TSelectedFields
 	> {
@@ -143,6 +143,7 @@ export interface MySqlSetOperatorBase<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
@@ -336,7 +337,7 @@ applyMixins(MySqlSetOperatorBase, [QueryPromise]);
 function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		if (restSelects.length === 0) {
-			return new MySqlSetOperatorBase(type, isAll, leftSelect, rightSelect as any);
+			return new MySqlSetOperatorBase(type, isAll, leftSelect, rightSelect as any) as any;
 		}
 
 		const [select, ...rest] = restSelects;
diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 330ef45be..f86923a71 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -29,6 +29,7 @@ import {
 	and,
 	type DriverValueEncoder,
 	eq,
+	type Name,
 	Param,
 	type QueryTypingsValue,
 	type QueryWithTypings,
@@ -361,19 +362,19 @@ export class PgDialect {
 
 		let orderBySql;
 		if (orderBy && orderBy.length > 0) {
-			const orderByValues: SQL<unknown>[] = [];
+			const orderByValues: (SQL<unknown> | Name)[] = [];
 
 			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
 			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
 			for (const singleOrderBy of orderBy) {
 				if (is(singleOrderBy, PgColumn)) {
-					orderByValues.push(sql.raw(singleOrderBy.name));
+					orderByValues.push(sql.identifier(singleOrderBy.name));
 				} else if (is(singleOrderBy, SQL)) {
 					for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {
 						const chunk = singleOrderBy.queryChunks[i];
 
 						if (is(chunk, PgColumn)) {
-							singleOrderBy.queryChunks[i] = sql.raw(chunk.name);
+							singleOrderBy.queryChunks[i] = sql.identifier(chunk.name);
 						}
 					}
 
diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index 6894f03b7..351163aaf 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -126,7 +126,7 @@ export abstract class PgSelectQueryBuilderBase<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends PgSetOperatorBuilder<
 	THKT,
@@ -514,7 +514,7 @@ export interface PgSelectBase<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
 	PgSelectQueryBuilderBase<
diff --git a/drizzle-orm/src/pg-core/query-builders/select.types.ts b/drizzle-orm/src/pg-core/query-builders/select.types.ts
index 949736a3a..832f2c37a 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.types.ts
@@ -6,6 +6,7 @@ import type {
 import type { PgColumn } from '~/pg-core/columns/index.ts';
 import type { PgTable, PgTableWithColumns } from '~/pg-core/table.ts';
 import type { PgViewBase, PgViewWithSelection } from '~/pg-core/view.ts';
+import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	AppendToNullabilityMap,
 	AppendToResult,
@@ -16,14 +17,16 @@ import type {
 	MapColumnsToTableAlias,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import type { Placeholder, SQL, SQLWrapper } from '~/sql/index.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
-import type { Assume, ValueOrArray } from '~/utils.ts';
+import type { Assume, ValidateShape, ValueOrArray } from '~/utils.ts';
 import type { ColumnsSelection, View } from '~/view.ts';
 import type { PreparedQuery, PreparedQueryConfig } from '../session.ts';
 import type { PgSelectBase, PgSelectQueryBuilderBase } from './select.ts';
+import type { PgSetOperatorBase, PgSetOperatorBuilder } from './set-operators.ts';
 
 export interface PgSelectJoinConfig {
 	on: SQL | undefined;
@@ -175,7 +178,7 @@ export interface PgSelectQueryBuilderHKT extends PgSelectHKTBase {
 		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
 		this['dynamic'],
 		this['excludedMethods'],
-		this['result'],
+		Assume<this['result'], any[]>,
 		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
@@ -188,7 +191,7 @@ export interface PgSelectHKT extends PgSelectHKTBase {
 		Assume<this['nullabilityMap'], Record<string, JoinNullability>>,
 		this['dynamic'],
 		this['excludedMethods'],
-		this['result'],
+		Assume<this['result'], any[]>,
 		Assume<this['selectedFields'], ColumnsSelection>
 	>;
 }
@@ -244,7 +247,7 @@ export type PgSelectQueryBuilder<
 	TSelection extends ColumnsSelection = ColumnsSelection,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-	TResult = unknown,
+	TResult extends any[] = unknown[],
 	TSelectedFields extends ColumnsSelection = ColumnsSelection,
 > = PgSelectQueryBuilderBase<
 	THKT,
@@ -268,3 +271,202 @@ export type PgSelect<
 > = PgSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
 
 export type AnyPgSelect = PgSelectBase<any, any, any, any, any, any, any, any>;
+
+export type PgSetOperatorBaseWithResult<T extends any[]> = PgSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	T,
+	any
+>;
+
+export type SetOperatorRightSelect<
+	TValue extends PgSetOperatorBaseWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
+			TValueObj,
+			TResult[number],
+			TypedQueryBuilder<any, TValueResult>
+		>
+	: never
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly PgSetOperatorBaseWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends PgSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+		? TValueResult extends Array<infer TValueObj>
+			? Rest extends PgSetOperatorInterface<any, any, any, any, any, any, any, any, any>[] ? [
+					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
+					...SetOperatorRestSelect<Rest, TResult>,
+				]
+			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+		: never
+	: never
+	: TValue;
+
+export interface PgSetOperationConfig {
+	fields: Record<string, unknown>;
+	operator: SetOperator;
+	isAll: boolean;
+	leftSelect: AnyPgSetOperatorBase;
+	rightSelect: TypedQueryBuilder<any, any[]>;
+	limit?: number | Placeholder;
+	orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+	offset?: number | Placeholder;
+}
+
+export interface PgSetOperatorInterface<
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+> extends
+	Omit<
+		PgSetOperatorBuilder<
+			THKT,
+			TTableName,
+			TSelection,
+			TSelectMode,
+			TNullabilityMap,
+			TDynamic,
+			TExcludedMethods,
+			TResult,
+			TSelectedFields
+		>,
+		'joinsNotNullableMap' | 'session' | 'dialect' | 'createSetOperator'
+	>
+{
+	_: {
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+}
+
+export type AnyPgSetOperatorBase = PgSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type PgCreateSetOperatorFn = <
+	THKT extends PgSelectHKTBase,
+	TTableName extends string | undefined,
+	TSelection extends ColumnsSelection,
+	TSelectMode extends SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability>,
+	TValue extends PgSetOperatorBaseWithResult<TResult>,
+	TRest extends PgSetOperatorBaseWithResult<TResult>[],
+	TDynamic extends boolean = false,
+	TExcludedMethods extends string = never,
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
+>(
+	leftSelect: PgSetOperatorInterface<
+		THKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
+	rightSelect: SetOperatorRightSelect<TValue, TResult>,
+	...restSelects: SetOperatorRestSelect<TRest, TResult>
+) => PgSetOperatorBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	false,
+	never,
+	TResult,
+	TSelectedFields
+>;
+
+export type AnyPgSetOperator = PgSetOperatorBase<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type PgSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgSetOperatorBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnyPgSetOperatorBuilder = PgSetOperatorBuilder<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
+
+export type PgSetOperatorWithout<
+	T extends AnyPgSetOperator,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		PgSetOperatorBase<
+			T['_']['tableName'],
+			T['_']['selection'],
+			T['_']['selectMode'],
+			T['_']['nullabilityMap'],
+			TDynamic,
+			T['_']['excludedMethods'] | K,
+			T['_']['result'],
+			T['_']['selectedFields']
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type PgSetOperatorDynamic<T extends AnyPgSetOperatorBuilder> = PgSetOperatorBase<
+	T['_']['tableName'],
+	T['_']['selection'],
+	T['_']['selectMode'],
+	T['_']['nullabilityMap'],
+	true,
+	never,
+	T['_']['result'],
+	T['_']['selectedFields']
+>;
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index f40893c87..31ee78c0e 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -15,17 +15,25 @@ import type {
 	JoinNullability,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import { tracer } from '~/tracing.ts';
-import { applyMixins, haveSameKeys, type ValidateShape } from '~/utils.ts';
+import { applyMixins, haveSameKeys } from '~/utils.ts';
 import { type ColumnsSelection } from '~/view.ts';
 import { type PgColumn } from '../columns/common.ts';
 import type { PgDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
-import type { PgSelectHKTBase } from './select.types.ts';
-
-type SetOperator = 'union' | 'intersect' | 'except';
+import type {
+	PgCreateSetOperatorFn,
+	PgSelectHKTBase,
+	PgSetOperationConfig,
+	PgSetOperatorBaseWithResult,
+	PgSetOperatorDynamic,
+	PgSetOperatorInterface,
+	PgSetOperatorWithout,
+	SetOperatorRightSelect,
+} from './select.types.ts';
 
 const getPgSetOperators = () => {
 	return {
@@ -40,44 +48,7 @@ const getPgSetOperators = () => {
 
 type PgSetOperators = ReturnType<typeof getPgSetOperators>;
 
-type SetOperatorRightSelect<
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-> = TValue extends PgSetOperatorBuilder<any, any, infer TSel, infer TMode, infer TNull> ? ValidateShape<
-		SelectResult<TSel, TMode, TNull>,
-		SelectResult<TSelection, TSelectMode, TNullabilityMap>,
-		TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>
-	>
-	: TValue;
-
-type SetOperatorRestSelect<
-	TValue extends readonly TypedQueryBuilder<any, any[]>[],
-	Valid,
-> = TValue extends [infer First, ...infer Rest]
-	? First extends PgSetOperatorBuilder<any, any, infer TSel, infer TMode, infer TNull>
-		? Rest extends TypedQueryBuilder<any, any[]>[] ? [
-				ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue[0]>,
-				...SetOperatorRestSelect<Rest, Valid>,
-			]
-		: ValidateShape<SelectResult<TSel, TMode, TNull>, Valid, TValue>
-	: never[]
-	: TValue;
-
-export interface PgSetOperationConfig {
-	fields: Record<string, unknown>;
-	operator: SetOperator;
-	isAll: boolean;
-	leftSelect: PgSetOperatorBuilder<any, any, any, any, any, any, any, any, any>;
-	rightSelect: TypedQueryBuilder<any, any[]>;
-	limit?: number | Placeholder;
-	orderBy?: (PgColumn | SQL | SQL.Aliased)[];
-	offset?: number | Placeholder;
-}
-
 export abstract class PgSetOperatorBuilder<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
@@ -86,11 +57,23 @@ export abstract class PgSetOperatorBuilder<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'PgSetOperatorBuilder';
 
+	abstract override readonly _: {
+		readonly hkt: THKT;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+
 	protected abstract joinsNotNullableMap: Record<string, boolean>;
 	protected abstract config: {
 		fields: Record<string, unknown>;
@@ -115,25 +98,24 @@ export abstract class PgSetOperatorBuilder<
 	private setOperator(
 		type: SetOperator,
 		isAll: boolean,
-	): <TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>>(
+	): <TValue extends PgSetOperatorBaseWithResult<TResult>>(
 		rightSelect:
-			| SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>
-			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>),
-	) => PgSetOperator<
-		THKT,
+			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => PgSetOperatorBase<
 		TTableName,
 		TSelection,
 		TSelectMode,
 		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
+		false,
+		never,
 		TResult,
 		TSelectedFields
 	> {
 		return (rightSelect) => {
 			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
 
-			return new PgSetOperator(type, isAll, this, rightSelectOrig);
+			return new PgSetOperatorBase(type, isAll, this, rightSelectOrig as any) as any;
 		};
 	}
 
@@ -150,9 +132,7 @@ export abstract class PgSetOperatorBuilder<
 	exceptAll = this.setOperator('except', true);
 }
 
-export interface PgSetOperator<
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	THKT extends PgSelectHKTBase,
+export interface PgSetOperatorBase<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -160,11 +140,11 @@ export interface PgSetOperator<
 		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
+	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
 	PgSetOperatorBuilder<
-		THKT,
+		PgSelectHKTBase,
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -177,8 +157,7 @@ export interface PgSetOperator<
 	QueryPromise<TResult>
 {}
 
-export class PgSetOperator<
-	THKT extends PgSelectHKTBase,
+export class PgSetOperatorBase<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -189,7 +168,7 @@ export class PgSetOperator<
 	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends PgSetOperatorBuilder<
-	THKT,
+	PgSelectHKTBase,
 	TTableName,
 	TSelection,
 	TSelectMode,
@@ -201,6 +180,18 @@ export class PgSetOperator<
 > {
 	static readonly [entityKind]: string = 'PgSetOperator';
 
+	readonly _: {
+		readonly hkt: PgSelectHKTBase;
+		readonly tableName: TTableName;
+		readonly selection: TSelection;
+		readonly selectMode: TSelectMode;
+		readonly nullabilityMap: TNullabilityMap;
+		readonly dynamic: TDynamic;
+		readonly excludedMethods: TExcludedMethods;
+		readonly result: TResult;
+		readonly selectedFields: TSelectedFields;
+	};
+
 	protected joinsNotNullableMap: Record<string, boolean>;
 	protected config: PgSetOperationConfig;
 	/* @internal */
@@ -210,8 +201,8 @@ export class PgSetOperator<
 	constructor(
 		operator: SetOperator,
 		isAll: boolean,
-		leftSelect: PgSetOperatorBuilder<
-			THKT,
+		leftSelect: PgSetOperatorInterface<
+			PgSelectHKTBase,
 			TTableName,
 			TSelection,
 			TSelectMode,
@@ -221,7 +212,7 @@ export class PgSetOperator<
 			TResult,
 			TSelectedFields
 		>,
-		rightSelect: TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
+		rightSelect: TypedQueryBuilder<any, TResult>,
 	) {
 		super();
 
@@ -252,13 +243,15 @@ export class PgSetOperator<
 		};
 	}
 
-	orderBy(builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>): this;
-	orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): this;
+	orderBy(
+		builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>,
+	): PgSetOperatorWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): PgSetOperatorWithout<this, TDynamic, 'orderBy'>;
 	orderBy(
 		...columns:
 			| [(aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>]
 			| (PgColumn | SQL | SQL.Aliased)[]
-	) {
+	): PgSetOperatorWithout<this, TDynamic, 'orderBy'> {
 		if (typeof columns[0] === 'function') {
 			const orderBy = columns[0](
 				new Proxy(
@@ -270,17 +263,17 @@ export class PgSetOperator<
 		} else {
 			this.config.orderBy = columns as (PgColumn | SQL | SQL.Aliased)[];
 		}
-		return this;
+		return this as any;
 	}
 
-	limit(limit: number) {
+	limit(limit: number): PgSetOperatorWithout<this, TDynamic, 'limit'> {
 		this.config.limit = limit;
-		return this;
+		return this as any;
 	}
 
-	offset(offset: number | Placeholder) {
+	offset(offset: number | Placeholder): PgSetOperatorWithout<this, TDynamic, 'offset'> {
 		this.config.offset = offset;
-		return this;
+		return this as any;
 	}
 
 	toSQL(): Query {
@@ -340,32 +333,28 @@ export class PgSetOperator<
 			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
 		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
 	}
+
+	$dynamic(): PgSetOperatorDynamic<this> {
+		return this as any;
+	}
 }
 
-applyMixins(PgSetOperator, [QueryPromise]);
+applyMixins(PgSetOperatorBase, [QueryPromise]);
 
-function setOperator(type: SetOperator, isAll: boolean): <
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>,
-	TRest extends TypedQueryBuilder<any, SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>[],
->(
-	leftSelect: PgSetOperatorBuilder<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap>,
-	rightSelect: SetOperatorRightSelect<TValue, TSelection, TSelectMode, TNullabilityMap>,
-	...restSelects: SetOperatorRestSelect<TRest, SelectResult<TSelection, TSelectMode, TNullabilityMap>>
-) => PgSetOperator<THKT, TTableName, TSelection, TSelectMode, TNullabilityMap> {
+function setOperator(type: SetOperator, isAll: boolean): PgCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		if (restSelects.length === 0) {
-			return new PgSetOperator(type, isAll, leftSelect, rightSelect);
+			return new PgSetOperatorBase(type, isAll, leftSelect, rightSelect as any) as any;
 		}
 
 		const [select, ...rest] = restSelects;
 		if (!select) throw new Error('Cannot pass undefined values to any set operator');
 
-		return setOperator(type, isAll)(new PgSetOperator(type, isAll, leftSelect, rightSelect), select, ...rest);
+		return setOperator(type, isAll)(
+			new PgSetOperatorBase(type, isAll, leftSelect, rightSelect as any),
+			select as any,
+			...rest,
+		);
 	};
 }
 
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index 5070f701b..925ec9758 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -16,7 +16,7 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { and, eq, Name, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
+import { and, eq, type Name, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
 import { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 import type {
 	SQLiteDeleteConfig,
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 9f8634be0..3e4c7fe3f 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -25,8 +25,7 @@ import type {
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import { type ColumnsSelection, type View } from '~/view.ts';
-import type { SQLiteDialect } from '../dialect.ts';
-import type { SQLitePreparedQuery, SQLiteSession } from '../session.ts';
+import type { SQLitePreparedQuery } from '../session.ts';
 import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.ts';
 import type { SQLiteSelectBase, SQLiteSelectQueryBuilderBase } from './select.ts';
 import type { SQLiteSetOperatorBase, SQLiteSetOperatorBuilder } from './set-operators.ts';
@@ -372,9 +371,21 @@ export interface SQLiteSetOperatorInterface<
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	TypedQueryBuilder<
-		TSelectedFields,
-		TResult
+	Omit<
+		SQLiteSetOperatorBuilder<
+			THKT,
+			TTableName,
+			TResultType,
+			TRunResult,
+			TSelection,
+			TSelectMode,
+			TNullabilityMap,
+			TDynamic,
+			TExcludedMethods,
+			TResult,
+			TSelectedFields
+		>,
+		'joinsNotNullableMap' | 'session' | 'dialect' | 'createSetOperator'
 	>
 {
 	_: {
@@ -391,13 +402,6 @@ export interface SQLiteSetOperatorInterface<
 		readonly result: TResult;
 		readonly selectedFields: TSelectedFields;
 	};
-	getSelectedFields: () => TSelectedFields;
-	getSetOperatorConfig: () => {
-		session: SQLiteSession<any, any, any, any> | undefined;
-		dialect: SQLiteDialect;
-		joinsNotNullableMap: Record<string, boolean>;
-		fields: Record<string, unknown>;
-	};
 }
 
 export type AnySQLiteSetOperatorBase = SQLiteSetOperatorInterface<
@@ -451,8 +455,8 @@ export type SQLiteCreateSetOperatorFn = <
 	TSelection,
 	TSelectMode,
 	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
+	false,
+	never,
 	TResult,
 	TSelectedFields
 >;
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
index 930a13abf..1538a1b0b 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
@@ -115,20 +115,15 @@ export abstract class SQLiteSetOperatorBuilder<
 		TSelection,
 		TSelectMode,
 		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
+		false,
+		never,
 		TResult,
 		TSelectedFields
 	> {
 		return (rightSelect) => {
 			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
 
-			return new SQLiteSetOperatorBase(
-				type,
-				isAll,
-				this,
-				rightSelectOrig as any,
-			);
+			return new SQLiteSetOperatorBase(type, isAll, this, rightSelectOrig as any) as any;
 		};
 	}
 
@@ -358,7 +353,7 @@ applyMixins(SQLiteSetOperatorBase, [QueryPromise]);
 function createSetOperator(type: SetOperator, isAll: boolean): SQLiteCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		if (restSelects.length === 0) {
-			return new SQLiteSetOperatorBase(type, isAll, leftSelect, rightSelect as any);
+			return new SQLiteSetOperatorBase(type, isAll, leftSelect, rightSelect as any) as any;
 		}
 
 		const [select, ...rest] = restSelects;
diff --git a/drizzle-orm/type-tests/mysql/set-operators.ts b/drizzle-orm/type-tests/mysql/set-operators.ts
index a936868ed..9afac2346 100644
--- a/drizzle-orm/type-tests/mysql/set-operators.ts
+++ b/drizzle-orm/type-tests/mysql/set-operators.ts
@@ -120,7 +120,7 @@ const intersect2Test = await intersect(
 
 Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
 
-const intersectAll2Test = await intersect(
+const intersectAll2Test = await intersectAll(
 	union(
 		db.select({
 			id: cities.id,
@@ -150,7 +150,7 @@ const except2Test = await except(
 
 Expect<Equal<{ userId: number }[], typeof except2Test>>;
 
-const exceptAll2Test = await except(
+const exceptAll2Test = await exceptAll(
 	db.select({
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
@@ -213,16 +213,7 @@ await db
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
 	// @ts-expect-error
-	.intersect(({ intersect }) =>
-		intersect(
-			db
-				.select()
-				.from(users),
-			db
-				.select()
-				.from(users),
-		)
-	);
+	.intersect(({ intersect }) => intersect(db.select().from(users), db.select().from(users)));
 
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type
diff --git a/drizzle-orm/type-tests/pg/set-operators.ts b/drizzle-orm/type-tests/pg/set-operators.ts
index 4394fa43d..3d53c4043 100644
--- a/drizzle-orm/type-tests/pg/set-operators.ts
+++ b/drizzle-orm/type-tests/pg/set-operators.ts
@@ -1,6 +1,6 @@
 import { type Equal, Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
-import { except, exceptAll, intersect, intersectAll, union, unionAll } from '~/pg-core/index.ts';
+import { except, exceptAll, intersect, intersectAll, type PgSetOperator, union, unionAll } from '~/pg-core/index.ts';
 import { desc, sql } from '~/sql/index.ts';
 import { db } from './db.ts';
 import { cities, classes, newYorkers, users } from './tables.ts';
@@ -17,15 +17,15 @@ const unionTest = await db
 Expect<Equal<{ id: number }[], typeof unionTest>>;
 
 const unionAllTest = await db
-	.select({ id: users.id, text: users.text })
+	.select({ id: users.id, age: users.age1 })
 	.from(users)
 	.unionAll(
-		db.select({ id: users.id, text: users.text })
+		db.select({ id: users.id, age: users.age1 })
 			.from(users)
 			.leftJoin(cities, eq(users.id, cities.id)),
 	);
 
-Expect<Equal<{ id: number; text: string | null }[], typeof unionAllTest>>;
+Expect<Equal<{ id: number; age: number }[], typeof unionAllTest>>;
 
 const intersectTest = await db
 	.select({ id: users.id, homeCity: users.homeCity })
@@ -46,7 +46,7 @@ Expect<Equal<{ id: number; homeCity: number }[], typeof intersectTest>>;
 const intersectAllTest = await db
 	.select({ id: users.id, homeCity: users.class })
 	.from(users)
-	.intersectAll(
+	.intersect(
 		db
 			.select({ id: users.id, homeCity: users.class })
 			.from(users)
@@ -69,7 +69,7 @@ Expect<Equal<{ id: number; homeCity: number }[], typeof exceptTest>>;
 const exceptAllTest = await db
 	.select({ id: users.id, homeCity: users.class })
 	.from(users)
-	.exceptAll(
+	.except(
 		db
 			.select({ id: users.id, homeCity: sql<'A' | 'C'>`${users.class}` })
 			.from(users),
@@ -113,9 +113,15 @@ const intersect2Test = await intersect(
 Expect<Equal<{ id: number; name: string; population: number | null }[], typeof intersect2Test>>;
 
 const intersectAll2Test = await intersectAll(
-	db.select({
-		id: cities.id,
-	}).from(cities),
+	union(
+		db.select({
+			id: cities.id,
+		}).from(cities),
+		db.select({
+			id: cities.id,
+		})
+			.from(cities).where(sql``),
+	),
 	db.select({
 		id: cities.id,
 	})
@@ -141,27 +147,85 @@ const exceptAll2Test = await exceptAll(
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
 	})
-		.from(newYorkers),
+		.from(newYorkers).where(sql``),
 	db.select({
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
-	}).from(newYorkers),
+	}).from(newYorkers).leftJoin(newYorkers, sql``),
 );
 
 Expect<Equal<{ userId: number; cityId: number | null }[], typeof exceptAll2Test>>;
 
+const unionfull = await union(db.select().from(users), db.select().from(users)).orderBy(sql``).limit(1).offset(2);
+
+Expect<
+	Equal<{
+		id: number;
+		uuid: string;
+		homeCity: number;
+		currentCity: number | null;
+		serialNullable: number;
+		serialNotNull: number;
+		class: 'A' | 'C';
+		subClass: 'B' | 'D' | null;
+		text: string | null;
+		age1: number;
+		createdAt: Date;
+		enumCol: 'a' | 'b' | 'c';
+		arrayCol: string[];
+	}[], typeof unionfull>
+>;
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+union(db.select().from(users), db.select().from(users))
+	.offset(1)
+	// @ts-expect-error - method was already called
+	.offset(2);
+
+union(db.select().from(users), db.select().from(users))
+	.orderBy(sql``)
+	// @ts-expect-error - method was already called
+	.orderBy(sql``);
+
+{
+	function dynamic<T extends PgSetOperator>(qb: T) {
+		return qb.orderBy(sql``).limit(1).offset(2);
+	}
+
+	const qb = union(db.select().from(users), db.select().from(users)).$dynamic();
+	const result = await dynamic(qb);
+	Expect<Equal<typeof result, typeof users.$inferSelect[]>>;
+}
+
+await db
+	.select({ id: users.id, homeCity: users.homeCity })
+	.from(users)
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	.intersect(({ intersect }) => intersect(db.select().from(users), db.select().from(users)));
+
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type
 // @ts-expect-error
 db.select().from(classes).union(db.select({ id: classes.id }).from(classes));
 
+// All queries in combining statements should return the same number of columns
+// and the corresponding columns should have compatible data type
+// @ts-expect-error
+db.select({ id: classes.id }).from(classes).union(db.select().from(classes).where(sql``));
+
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type
 // @ts-expect-error
 db.select({ id: classes.id }).from(classes).union(db.select().from(classes));
 
 union(
-	db.select({ id: cities.id, name: cities.name }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
@@ -169,6 +233,16 @@ union(
 	db.select().from(cities),
 );
 
+union(
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``),
+	// All queries in combining statements should return the same number of columns
+	// and the corresponding columns should have compatible data type
+	// @ts-expect-error
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name }).from(cities).where(sql``).limit(3).$dynamic(),
+	db.select({ id: cities.id, name: cities.name }).from(cities),
+);
+
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
@@ -189,18 +263,18 @@ union(
 	// @ts-expect-error
 	db.select({ id: cities.id, name: cities.name }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
+	db.select({ id: newYorkers.userId }).from(newYorkers),
 	db.select({ id: cities.id }).from(cities),
 );
 
 union(
 	db.select({ id: cities.id }).from(cities),
 	db.select({ id: cities.id }).from(cities),
-	db.select({ id: cities.id }).from(cities),
+	db.select({ id: cities.id }).from(cities).where(sql``),
 	db.select({ id: sql<number>`${cities.id}` }).from(cities),
 	db.select({ id: cities.id }).from(cities),
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
 	// @ts-expect-error
-	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities),
+	db.select({ id: cities.id, name: cities.name, population: cities.population }).from(cities).where(sql``),
 );
diff --git a/drizzle-orm/type-tests/sqlite/set-operators.ts b/drizzle-orm/type-tests/sqlite/set-operators.ts
index 86734c2bb..e0239ba24 100644
--- a/drizzle-orm/type-tests/sqlite/set-operators.ts
+++ b/drizzle-orm/type-tests/sqlite/set-operators.ts
@@ -147,7 +147,7 @@ const exceptAll2Test = await except(
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
 	})
-		.from(newYorkers).where(sql``),
+		.from(newYorkers).where(eq(newYorkers.cityId, 2)),
 	db.select({
 		userId: newYorkers.userId,
 		cityId: newYorkers.cityId,
@@ -205,16 +205,7 @@ await db
 	// All queries in combining statements should return the same number of columns
 	// and the corresponding columns should have compatible data type
 	// @ts-expect-error
-	.intersect(({ intersect }) =>
-		intersect(
-			db
-				.select()
-				.from(users),
-			db
-				.select()
-				.from(users),
-		)
-	);
+	.intersect(({ intersect }) => intersect(db.select().from(users), db.select().from(users)));
 
 // All queries in combining statements should return the same number of columns
 // and the corresponding columns should have compatible data type

From 57889e17d89cf62a2b36057cf0394e686a868f2b Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Sat, 14 Oct 2023 21:54:36 -0400
Subject: [PATCH 55/72] [All] fix typescript errors

---
 drizzle-orm/src/mysql-core/dialect.ts                      | 4 ++--
 drizzle-orm/src/mysql-core/query-builders/set-operators.ts | 2 +-
 drizzle-orm/src/pg-core/query-builders/set-operators.ts    | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index fe936d97f..4d3edfeca 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -18,8 +18,8 @@ import { and, eq, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
-import { View, ViewBaseConfig } from '~/view.ts';
-import { DrizzleError, type Name } from '../index.ts';
+import { View } from '~/view.ts';
+import { DrizzleError, type Name, ViewBaseConfig } from '../index.ts';
 import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
index 7b1b742ce..92b5d3680 100644
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
@@ -25,7 +25,7 @@ import type {
 	SelectResult,
 	SetOperator,
 } from '~/query-builders/select.types.ts';
-import { type ColumnsSelection } from '~/view.ts';
+import type { ColumnsSelection } from '~/view.ts';
 import type { MySqlColumn } from '../columns/common.ts';
 import type { MySqlDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
index 31ee78c0e..27c024f1c 100644
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
@@ -20,8 +20,8 @@ import type {
 import { QueryPromise } from '~/query-promise.ts';
 import { tracer } from '~/tracing.ts';
 import { applyMixins, haveSameKeys } from '~/utils.ts';
-import { type ColumnsSelection } from '~/view.ts';
-import { type PgColumn } from '../columns/common.ts';
+import type { ColumnsSelection } from '~/view.ts';
+import type { PgColumn } from '../columns/common.ts';
 import type { PgDialect } from '../dialect.ts';
 import type { SubqueryWithSelection } from '../subquery.ts';
 import type {

From a6d3b9ad4edfad0b1dd275aada2dff2b4d9b5b55 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Mon, 16 Oct 2023 12:14:34 +0300
Subject: [PATCH 56/72] Fix types for replicas in MySQL and SQLite

---
 drizzle-orm/src/mysql-core/db.ts              |    7 +-
 drizzle-orm/src/sqlite-core/db.ts             |    7 +-
 .../tests/replicas/sqlite.test.ts             | 1047 ++++++++---------
 pnpm-lock.yaml                                |    2 +-
 4 files changed, 536 insertions(+), 527 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/db.ts b/drizzle-orm/src/mysql-core/db.ts
index 60dbff4dd..f7bd76e0c 100644
--- a/drizzle-orm/src/mysql-core/db.ts
+++ b/drizzle-orm/src/mysql-core/db.ts
@@ -183,7 +183,12 @@ export const withReplicas = <
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown>,
 	TSchema extends TablesRelationalConfig,
-	Q extends MySqlDatabase<HKT, TPreparedQueryHKT, TFullSchema, TSchema>,
+	Q extends MySqlDatabase<
+		HKT,
+		TPreparedQueryHKT,
+		TFullSchema,
+		TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema
+	>,
 >(
 	primary: Q,
 	replicas: [Q, ...Q[]],
diff --git a/drizzle-orm/src/sqlite-core/db.ts b/drizzle-orm/src/sqlite-core/db.ts
index ff676be88..2f36a4d43 100644
--- a/drizzle-orm/src/sqlite-core/db.ts
+++ b/drizzle-orm/src/sqlite-core/db.ts
@@ -233,7 +233,12 @@ export const withReplicas = <
 	TRunResult,
 	TFullSchema extends Record<string, unknown>,
 	TSchema extends TablesRelationalConfig,
-	Q extends BaseSQLiteDatabase<TResultKind, TRunResult, TFullSchema, TSchema>,
+	Q extends BaseSQLiteDatabase<
+		TResultKind,
+		TRunResult,
+		TFullSchema,
+		TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema
+	>,
 >(
 	primary: Q,
 	replicas: [Q, ...Q[]],
diff --git a/integration-tests/tests/replicas/sqlite.test.ts b/integration-tests/tests/replicas/sqlite.test.ts
index b55dce37c..b607ce1a0 100644
--- a/integration-tests/tests/replicas/sqlite.test.ts
+++ b/integration-tests/tests/replicas/sqlite.test.ts
@@ -1,719 +1,718 @@
-// import { sql } from 'drizzle-orm';
-// import { sqliteTable, int, text, withReplicas } from 'drizzle-orm/sqlite-core';
-// import { drizzle } from 'drizzle-orm/libsql';
-// import { describe, expect, it, vi } from 'vitest';
+import { sql } from 'drizzle-orm';
+import { sqliteTable, int, text, withReplicas } from 'drizzle-orm/sqlite-core';
+import { drizzle } from 'drizzle-orm/libsql';
+import { describe, expect, it, vi } from 'vitest';
 
-// const usersTable = sqliteTable('users', {
-// 	id: int('id' as string).primaryKey(),
-// 	name: text('name').notNull(),
-// });
+const usersTable = sqliteTable('users', {
+	id: int('id' as string).primaryKey(),
+	name: text('name').notNull(),
+});
 
-// describe('[select] read replicas postgres', () => {
-// 	it('primary select', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[select] read replicas postgres', () => {
+	it('primary select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
-// 		const spyRead1 = vi.spyOn(read1, 'select');
-// 		const spyRead2 = vi.spyOn(read2, 'select');
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
 
-// 		db.$primary.select().from({} as any);
+		db.$primary.select().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
 
-// 	it('random replica select', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+	it('random replica select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], () => {
-// 			return randomMockReplica();
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
-// 		const spyRead1 = vi.spyOn(read1, 'select');
-// 		const spyRead2 = vi.spyOn(read2, 'select');
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
 
-// 		db.select().from({} as any);
+		db.select().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.select().from({} as any);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(1);
-// 	});
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('single read replica select', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
+	it('single read replica select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
-// 		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
 
-// 		db.select().from({} as any);
+		db.select().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.select().from({} as any);
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	});
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
 
-// 	it('single read replica select + primary select', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
+	it('single read replica select + primary select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
-// 		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
 
-// 		db.select().from({} as any);
+		db.select().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.$primary.select().from({} as any);
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	});
+		db.$primary.select().from({} as any);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('always first read select', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+	it('always first read select', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-// 			return replicas[0]!;
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'select');
-// 		const spyRead1 = vi.spyOn(read1, 'select');
-// 		const spyRead2 = vi.spyOn(read2, 'select');
+		const spyPrimary = vi.spyOn(primaryDb, 'select');
+		const spyRead1 = vi.spyOn(read1, 'select');
+		const spyRead2 = vi.spyOn(read2, 'select');
 
-// 		db.select().from({} as any);
+		db.select().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.select().from({} as any);
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		db.select().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[selectDistinct] read replicas postgres', () => {
-// 	it('primary selectDistinct', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[selectDistinct] read replicas postgres', () => {
+	it('primary selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-// 		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
 
-// 		db.$primary.selectDistinct().from({} as any);
+		db.$primary.selectDistinct().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
 
-// 	it('random replica selectDistinct', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+	it('random replica selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], () => {
-// 			return randomMockReplica();
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-// 		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
 
-// 		db.selectDistinct().from({} as any);
+		db.selectDistinct().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.selectDistinct().from({} as any);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(1);
-// 	});
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('single read replica selectDistinct', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
+	it('single read replica selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
 
-// 		db.selectDistinct().from({} as any);
+		db.selectDistinct().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.selectDistinct().from({} as any);
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	});
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
 
-// 	it('single read replica selectDistinct + primary selectDistinct', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
+	it('single read replica selectDistinct + primary selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
 
-// 		db.selectDistinct().from({} as any);
+		db.selectDistinct().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.$primary.selectDistinct().from({} as any);
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	});
+		db.$primary.selectDistinct().from({} as any);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('always first read selectDistinct', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+	it('always first read selectDistinct', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-// 			return replicas[0]!;
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
-// 		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
-// 		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
+		const spyPrimary = vi.spyOn(primaryDb, 'selectDistinct');
+		const spyRead1 = vi.spyOn(read1, 'selectDistinct');
+		const spyRead2 = vi.spyOn(read2, 'selectDistinct');
 
-// 		db.selectDistinct().from({} as any);
+		db.selectDistinct().from({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.selectDistinct().from({} as any);
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		db.selectDistinct().from({} as any);
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[with] read replicas postgres', () => {
-// 	it('primary with', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[with] read replicas postgres', () => {
+	it('primary with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
-// 		const spyRead1 = vi.spyOn(read1, 'with');
-// 		const spyRead2 = vi.spyOn(read2, 'with');
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
 
-// 		db.$primary.with();
+		db.$primary.with();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
 
-// 	it('random replica with', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+	it('random replica with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], () => {
-// 			return randomMockReplica();
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
-// 		const spyRead1 = vi.spyOn(read1, 'with');
-// 		const spyRead2 = vi.spyOn(read2, 'with');
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
 
-// 		db.with();
+		db.with();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.with();
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(1);
-// 	});
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('single read replica with', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
+	it('single read replica with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
-// 		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
 
-// 		db.with();
+		db.with();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.with();
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	});
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
 
-// 	it('single read replica with + primary with', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
+	it('single read replica with + primary with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
-// 		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
 
-// 		db.with();
+		db.with();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.$primary.with();
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	});
+		db.$primary.with();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('always first read with', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+	it('always first read with', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-// 			return replicas[0]!;
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'with');
-// 		const spyRead1 = vi.spyOn(read1, 'with');
-// 		const spyRead2 = vi.spyOn(read2, 'with');
+		const spyPrimary = vi.spyOn(primaryDb, 'with');
+		const spyRead1 = vi.spyOn(read1, 'with');
+		const spyRead2 = vi.spyOn(read2, 'with');
 
-// 		db.with();
+		db.with();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.with();
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		db.with();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[update] replicas postgres', () => {
-// 	it('primary update', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[update] replicas postgres', () => {
+	it('primary update', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'update');
-// 		const spyRead1 = vi.spyOn(read1, 'update');
-// 		const spyRead2 = vi.spyOn(read2, 'update');
+		const spyPrimary = vi.spyOn(primaryDb, 'update');
+		const spyRead1 = vi.spyOn(read1, 'update');
+		const spyRead2 = vi.spyOn(read2, 'update');
 
-// 		db.update({} as any);
+		db.update({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.update({} as any);
+		db.update({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.$primary.update({} as any);
+		db.$primary.update({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[delete] replicas postgres', () => {
-// 	it('primary delete', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[delete] replicas postgres', () => {
+	it('primary delete', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'delete');
-// 		const spyRead1 = vi.spyOn(read1, 'delete');
-// 		const spyRead2 = vi.spyOn(read2, 'delete');
+		const spyPrimary = vi.spyOn(primaryDb, 'delete');
+		const spyRead1 = vi.spyOn(read1, 'delete');
+		const spyRead2 = vi.spyOn(read2, 'delete');
 
-// 		db.delete({} as any);
+		db.delete({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.delete({} as any);
+		db.delete({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.$primary.delete({} as any);
+		db.$primary.delete({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[insert] replicas postgres', () => {
-// 	it('primary insert', () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[insert] replicas postgres', () => {
+	it('primary insert', () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'insert');
-// 		const spyRead1 = vi.spyOn(read1, 'insert');
-// 		const spyRead2 = vi.spyOn(read2, 'insert');
+		const spyPrimary = vi.spyOn(primaryDb, 'insert');
+		const spyRead1 = vi.spyOn(read1, 'insert');
+		const spyRead2 = vi.spyOn(read2, 'insert');
 
-// 		db.insert({} as any);
+		db.insert({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.insert({} as any);
+		db.insert({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.$primary.insert({} as any);
+		db.$primary.insert({} as any);
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[execute] replicas postgres', () => {
-// 	it('primary execute', async () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[execute] replicas postgres', () => {
+	it('primary execute', async () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'execute');
-// 		const spyRead1 = vi.spyOn(read1, 'execute');
-// 		const spyRead2 = vi.spyOn(read2, 'execute');
+		const spyPrimary = vi.spyOn(primaryDb, 'all');
+		const spyRead1 = vi.spyOn(read1, 'all');
+		const spyRead2 = vi.spyOn(read2, 'all');
 
-// 		// expect(db.execute(sql``)).rejects.toThrow();
+		// expect(db.execute(sql``)).rejects.toThrow();
 
-// 		try {
-// 			db.execute(sql``);
-// 		} catch { /* empty */ }
+		try {
+			db.all(sql``);
+		} catch { /* empty */ }
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		try {
-// 			db.execute(sql``);
-// 		} catch { /* empty */ }
+		try {
+			db.all(sql``);
+		} catch { /* empty */ }
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		try {
-// 			db.execute(sql``);
-// 		} catch { /* empty */ }
+		try {
+			db.all(sql``);
+		} catch { /* empty */ }
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[transaction] replicas postgres', () => {
-// 	it('primary transaction', async () => {
-// 		const primaryDb = drizzle({} as any);
-// 		const read1 = drizzle({} as any);
-// 		const read2 = drizzle({} as any);
+describe('[transaction] replicas postgres', () => {
+	it('primary transaction', async () => {
+		const primaryDb = drizzle({} as any);
+		const read1 = drizzle({} as any);
+		const read2 = drizzle({} as any);
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
-// 		const spyRead1 = vi.spyOn(read1, 'transaction');
-// 		const spyRead2 = vi.spyOn(read2, 'transaction');
+		const spyPrimary = vi.spyOn(primaryDb, 'transaction');
+		const spyRead1 = vi.spyOn(read1, 'transaction');
+		const spyRead2 = vi.spyOn(read2, 'transaction');
 
-// 		expect(db.transaction(async (tx) => {
-// 			tx.select().from({} as any);
-// 		})).rejects.toThrow();
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		expect(db.transaction(async (tx) => {
-// 			tx.select().from({} as any);
-// 		})).rejects.toThrow();
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(2);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(2);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		expect(db.transaction(async (tx) => {
-// 			tx.select().from({} as any);
-// 		})).rejects.toThrow();
+		expect(db.transaction(async (tx) => {
+			tx.select().from({} as any);
+		})).rejects.toThrow();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(3);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		expect(spyPrimary).toHaveBeenCalledTimes(3);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[findFirst] read replicas postgres', () => {
-// 	it('primary findFirst', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
-// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+describe('[findFirst] read replicas postgres', () => {
+	it('primary findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
-
-// 		db.$primary.query.usersTable.findFirst();
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+
+		db.$primary.query.usersTable.findFirst();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-
-// 	it('random replica findFirst', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
-// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+
+	it('random replica findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
 		
-// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], () => {
-// 			return randomMockReplica();
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
 
-// 		db.query.usersTable.findFirst();
+		db.query.usersTable.findFirst();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.query.usersTable.findFirst();
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(1);
-// 	});
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('single read replica findFirst', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+	it('single read replica findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
 
-// 		db.query.usersTable.findFirst();
+		db.query.usersTable.findFirst();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.query.usersTable.findFirst();
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	});
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
 
-// 	it('single read replica findFirst + primary findFirst', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+	it('single read replica findFirst + primary findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
 		
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
 
-// 		db.query.usersTable.findFirst();
+		db.query.usersTable.findFirst();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.$primary.query.usersTable.findFirst();
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	});
+		db.$primary.query.usersTable.findFirst();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('always first read findFirst', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
-// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+	it('always first read findFirst', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
 
-// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-// 			return replicas[0]!;
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
-// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findFirst');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findFirst');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findFirst');
 
-// 		db.query.usersTable.findFirst();
+		db.query.usersTable.findFirst();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.query.usersTable.findFirst();
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// });
+		db.query.usersTable.findFirst();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
 
-// describe('[findMany] read replicas postgres', () => {
-// 	it('primary findMany', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
-// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+describe('[findMany] read replicas postgres', () => {
+	it('primary findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
 
-// 		const db = withReplicas(primaryDb, [read1, read2]);
+		const db = withReplicas(primaryDb, [read1, read2]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
 
-// 		db.$primary.query.usersTable.findMany();
+		db.$primary.query.usersTable.findMany();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(0);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(0);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
 
-// 	it('random replica findMany', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
-// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+	it('random replica findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
 		
-// 		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
+		const randomMockReplica = vi.fn().mockReturnValueOnce(read1).mockReturnValueOnce(read2);
 
-// 		const db = withReplicas(primaryDb, [read1, read2], () => {
-// 			return randomMockReplica();
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], () => {
+			return randomMockReplica();
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
 
-// 		db.query.usersTable.findMany();
+		db.query.usersTable.findMany();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.query.usersTable.findMany();
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(1);
-// 	});
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('single read replica findMany', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+	it('single read replica findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
 
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
 
-// 		db.query.usersTable.findMany();
+		db.query.usersTable.findMany();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.query.usersTable.findMany();
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 	});
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+	});
 
-// 	it('single read replica findMany + primary findMany', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
+	it('single read replica findMany + primary findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
 		
-// 		const db = withReplicas(primaryDb, [read1]);
+		const db = withReplicas(primaryDb, [read1]);
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
 
-// 		db.query.usersTable.findMany();
+		db.query.usersTable.findMany();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
 
-// 		db.$primary.query.usersTable.findMany();
-// 		expect(spyPrimary).toHaveBeenCalledTimes(1);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 	});
+		db.$primary.query.usersTable.findMany();
+		expect(spyPrimary).toHaveBeenCalledTimes(1);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+	});
 
-// 	it('always first read findMany', () => {
-// 		const primaryDb = drizzle({} as any, { schema: { usersTable } });
-// 		const read1 = drizzle({} as any, { schema: { usersTable } });
-// 		const read2 = drizzle({} as any, { schema: { usersTable } });
+	it('always first read findMany', () => {
+		const primaryDb = drizzle({} as any, { schema: { usersTable } });
+		const read1 = drizzle({} as any, { schema: { usersTable } });
+		const read2 = drizzle({} as any, { schema: { usersTable } });
 
-// 		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
-// 			return replicas[0]!;
-// 		});
+		const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+			return replicas[0]!;
+		});
 
-// 		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
-// 		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
-// 		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
+		const spyPrimary = vi.spyOn(primaryDb['query']['usersTable'], 'findMany');
+		const spyRead1 = vi.spyOn(read1['query']['usersTable'], 'findMany');
+		const spyRead2 = vi.spyOn(read2['query']['usersTable'], 'findMany');
 
-// 		db.query.usersTable.findMany();
+		db.query.usersTable.findMany();
 
-// 		expect(spyPrimary).toHaveBeenCalledTimes(0);
-// 		expect(spyRead1).toHaveBeenCalledTimes(1);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
+		expect(spyPrimary).toHaveBeenCalledTimes(0);
+		expect(spyRead1).toHaveBeenCalledTimes(1);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
 
-// 		db.query.usersTable.findMany();
-// 		expect(spyRead1).toHaveBeenCalledTimes(2);
-// 		expect(spyRead2).toHaveBeenCalledTimes(0);
-// 	});
-// eslint-disable-next-line unicorn/no-empty-file
-// });
\ No newline at end of file
+		db.query.usersTable.findMany();
+		expect(spyRead1).toHaveBeenCalledTimes(2);
+		expect(spyRead2).toHaveBeenCalledTimes(0);
+	});
+});
\ No newline at end of file
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 937f0492e..d6f587854 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,4 +1,4 @@
-lockfileVersion: '6.0'
+lockfileVersion: '6.1'
 
 settings:
   autoInstallPeers: true

From 23cf493d5b475536618b585cb12ddc3473570965 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Mon, 16 Oct 2023 12:20:40 +0300
Subject: [PATCH 57/72] Exclude replicas from ava

---
 integration-tests/package.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/integration-tests/package.json b/integration-tests/package.json
index aeb2b6792..b14575401 100644
--- a/integration-tests/package.json
+++ b/integration-tests/package.json
@@ -22,7 +22,8 @@
       "!tests/vercel-pg.test.ts",
       "!tests/relational/**/*",
       "!tests/libsql-batch.test.ts",
-      "!tests/d1-batch.test.ts"
+      "!tests/d1-batch.test.ts",
+      "!tests/replicas/**/*"
     ],
     "extensions": {
       "ts": "module"

From 08e30435e9865c4322bc452c11e31cac06423f09 Mon Sep 17 00:00:00 2001
From: Dan Kochetov <danil.kochetov@gmail.com>
Date: Thu, 19 Oct 2023 20:20:51 +0300
Subject: [PATCH 58/72] Remove debug file

---
 output.txt | 62 ------------------------------------------------------
 1 file changed, 62 deletions(-)
 delete mode 100644 output.txt

diff --git a/output.txt b/output.txt
deleted file mode 100644
index fbafeba84..000000000
--- a/output.txt
+++ /dev/null
@@ -1,62 +0,0 @@
-
-> @ b /home/dan/dev/drizzle-orm
-> pnpm build
-
-
-> @ build /home/dan/dev/drizzle-orm
-> turbo run build test:types //#lint --color
-
-• Packages in scope: //, drizzle-orm, drizzle-typebox, drizzle-valibot, drizzle-zod, integration-tests
-• Running build, test:types, //#lint in 6 packages
-• Remote caching disabled
-//:lint: cache miss, executing 7f90a6b29f6344d4
-drizzle-orm:test:types: cache miss, executing 8ccd4eb5348eda9b
-drizzle-orm:build: cache miss, executing c099f6c3096b9a29
-drizzle-orm:test:types: 
-drizzle-orm:test:types: > drizzle-orm@0.28.7 test:types /home/dan/dev/drizzle-orm/drizzle-orm
-drizzle-orm:test:types: > cd type-tests && tsc
-drizzle-orm:test:types: 
-//:lint: 
-//:lint: > @ lint /home/dan/dev/drizzle-orm
-//:lint: > eslint --ext ts .
-//:lint: 
-drizzle-orm:build: 
-drizzle-orm:build: > drizzle-orm@0.28.7 build /home/dan/dev/drizzle-orm/drizzle-orm
-drizzle-orm:build: > scripts/build.ts
-drizzle-orm:build: 
-drizzle-orm:build: $ rollup --config rollup.cjs.config.ts --configPlugin typescript
-drizzle-orm:test:types: mysql/select.ts(505,35): error TS2345: Argument of type 'MySqlSelectBase<"users_table", { id: MySqlColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }, "single", PreparedQueryHKTBase, Record<"users_table", "not-null">, true, never, { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }[], { id: MySqlColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "users_table"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>' is not assignable to parameter of type 'MySqlSelectQueryBuilder'.
-drizzle-orm:test:types:   The types of '_.hkt._type.$dynamic()._.hkt' are incompatible between these types.
-drizzle-orm:test:types:     Type 'MySqlSelectHKT' is not assignable to type 'MySqlSelectQueryBuilderHKT & { tableName: string | undefined; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
-drizzle-orm:test:types:       Type 'MySqlSelectHKT' is not assignable to type '{ tableName: string | undefined; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
-drizzle-orm:test:types:         Types of property 'selection' are incompatible.
-drizzle-orm:test:types:           Type 'unknown' is not assignable to type 'ColumnsSelection'.
-drizzle-orm:test:types: mysql/select.ts(507,3): error TS2344: Type 'false' does not satisfy the constraint 'true'.
-drizzle-orm:test:types: mysql/select.ts(507,24): error TS2344: Type '{ users_table: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' does not satisfy the constraint 'MySqlSelectQueryBuilderBase<MySqlSelectQueryBuilderHKT & { tableName: string | undefined; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", PreparedQueryHKTBase, Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; })>'.
-drizzle-orm:test:types:   Type '{ users_table: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { text: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' is missing the following properties from type 'MySqlSelectQueryBuilderBase<MySqlSelectQueryBuilderHKT & { tableName: string | undefined; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: MySqlColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: MySqlColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends2"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: MySqlColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends3"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: MySqlColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends4"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: MySqlColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: MySqlColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: MySqlColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: MySqlColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: MySqlColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "MySqlSerial"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; class: MySqlColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: MySqlColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; text: MySqlColumn<{ name: "text"; tableName: "friends5"; dataType: "string"; columnType: "MySqlText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: MySqlColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "MySqlInt"; data: number; driverParam: string | number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: MySqlColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "MySqlTimestamp"; data: Date; driverParam: string | number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: MySqlColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "MySqlEnumColumn"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", PreparedQueryHKTBase, Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial1"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "serial2"; dataType: "number"; columnType: "MySqlSerial"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "MySqlText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; text: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "text"; dataType: "string"; columnType: "MySqlText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: string | number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "MySqlInt"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: string | number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "MySqlTimestamp"; enumValues: undefined; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "MySqlEnumColumn"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "mysql"; baseColumn: never; notNull: false; }, object, object>; }; })>': _, config, joinsNotNullableMap, tableName, and 20 more.
-drizzle-orm:test:types: sqlite/select.ts(510,35): error TS2345: Argument of type 'SQLiteSelectBase<"users_table", "sync", RunResult, { id: SQLiteColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }, "single", Record<"users_table", "not-null">, true, never, { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }[], { id: SQLiteColumn<{ name: "id"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "users_table"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "users_table"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "users_table"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>' is not assignable to parameter of type 'SQLiteSelectQueryBuilder'.
-drizzle-orm:test:types:   The types of '_.hkt._type.$dynamic()._.hkt' are incompatible between these types.
-drizzle-orm:test:types:     Type 'SQLiteSelectHKT' is not assignable to type 'SQLiteSelectQueryBuilderHKT & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
-drizzle-orm:test:types:       Type 'SQLiteSelectHKT' is not assignable to type '{ tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection; selectMode: SelectMode; nullabilityMap: Record<string, JoinNullability>; dynamic: true; excludedMethods: never; result: unknown; selectedFields: ColumnsSelection; }'.
-drizzle-orm:test:types:         Types of property 'selection' are incompatible.
-drizzle-orm:test:types:           Type 'unknown' is not assignable to type 'ColumnsSelection'.
-drizzle-orm:test:types: sqlite/select.ts(512,3): error TS2344: Type 'false' does not satisfy the constraint 'true'.
-drizzle-orm:test:types: sqlite/select.ts(512,24): error TS2344: Type '{ users_table: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' does not satisfy the constraint 'SQLiteSelectQueryBuilderBase<SQLiteSelectQueryBuilderHKT & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, "sync" | "async", unknown, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; })>'.
-drizzle-orm:test:types:   Type '{ users_table: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; }; friends: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends2: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends3: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends4: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; friends5: { name: string | null; id: number; createdAt: Date; homeCity: number; currentCity: number | null; serialNullable: number | null; serialNotNull: number; class: "A" | "C"; subClass: "B" | "D" | null; age1: number; enumCol: "a" | "b" | "c"; } | null; }[]' is missing the following properties from type 'SQLiteSelectQueryBuilderBase<SQLiteSelectQueryBuilderHKT & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>); selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; } & { tableName: string | undefined; resultType: "sync" | "async"; runResult: unknown; selection: ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>; selectMode: "multiple"; nullabilityMap: Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }; dynamic: true; excludedMethods: never; result: { [x: string]: null; }[]; selectedFields: { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }; }, string | undefined, "sync" | "async", unknown, (ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>) & (((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & ((ColumnsSelection | ((ColumnsSelection | Record<string, ColumnsSelection>) & Record<"friends", { id: SQLiteColumn<{ name: "id"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends2", { id: SQLiteColumn<{ name: "id"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends2"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends2"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends2"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends3", { id: SQLiteColumn<{ name: "id"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends3"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends3"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends3"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends4", { id: SQLiteColumn<{ name: "id"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends4"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends4"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends4"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>)) & Record<"friends5", { id: SQLiteColumn<{ name: "id"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; homeCity: SQLiteColumn<{ name: "home_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; currentCity: SQLiteColumn<{ name: "current_city"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNullable: SQLiteColumn<{ name: "serial1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: false; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; serialNotNull: SQLiteColumn<{ name: "serial2"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; class: SQLiteColumn<{ name: "class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "A" | "C"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["A", "C"]; baseColumn: never; }, object>; subClass: SQLiteColumn<{ name: "sub_class"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "B" | "D"; driverParam: string; notNull: false; hasDefault: false; enumValues: ["B", "D"]; baseColumn: never; }, object>; name: SQLiteColumn<{ name: "name"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: string; driverParam: string; notNull: false; hasDefault: false; enumValues: [string, ...string[]]; baseColumn: never; }, object>; age1: SQLiteColumn<{ name: "age1"; tableName: "friends5"; dataType: "number"; columnType: "SQLiteInteger"; data: number; driverParam: number; notNull: true; hasDefault: false; enumValues: undefined; baseColumn: never; }, object>; createdAt: SQLiteColumn<{ name: "created_at"; tableName: "friends5"; dataType: "date"; columnType: "SQLiteTimestamp"; data: Date; driverParam: number; notNull: true; hasDefault: true; enumValues: undefined; baseColumn: never; }, object>; enumCol: SQLiteColumn<{ name: "enum_col"; tableName: "friends5"; dataType: "string"; columnType: "SQLiteText"; data: "a" | "b" | "c"; driverParam: string; notNull: true; hasDefault: false; enumValues: ["a", "b", "c"]; baseColumn: never; }, object>; }>), "multiple", Record<string, JoinNullability> & { friends: "nullable"; } & { friends2: "nullable"; } & { friends3: "nullable"; } & { friends4: "nullable"; } & { friends5: "nullable"; }, true, never, { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[] & { [x: string]: null; }[], ({ [x: string]: never; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; }) & ({ [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: never; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; } | { [x: string]: { [x: string]: never; }; friends: { id: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends2: { id: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends2"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends2"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends2"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends2"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends3: { id: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends3"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends3"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends3"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends3"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends4: { id: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends4"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends4"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends4"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends4"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; friends5: { id: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: true; name: "id"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; homeCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "home_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; currentCity: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "current_city"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNullable: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; serialNotNull: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "serial2"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; class: Column<{ data: "A" | "C"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["A", "C"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; subClass: Column<{ data: "B" | "D"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "sub_class"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["B", "D"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; name: Column<{ data: string; driverParam: string; tableName: "friends5"; hasDefault: false; name: "name"; dataType: "string"; columnType: "SQLiteText"; enumValues: [string, ...string[]]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; age1: Column<{ data: number; driverParam: number; tableName: "friends5"; hasDefault: false; name: "age1"; dataType: "number"; columnType: "SQLiteInteger"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; createdAt: Column<{ data: Date; driverParam: number; tableName: "friends5"; hasDefault: true; name: "created_at"; dataType: "date"; columnType: "SQLiteTimestamp"; enumValues: undefined; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; enumCol: Column<{ data: "a" | "b" | "c"; driverParam: string; tableName: "friends5"; hasDefault: false; name: "enum_col"; dataType: "string"; columnType: "SQLiteText"; enumValues: ["a", "b", "c"]; brand: "Column"; dialect: "sqlite"; baseColumn: never; notNull: false; }, object, object>; }; })>': _, config, joinsNotNullableMap, tableName, and 19 more.
-drizzle-orm:test:types:  ELIFECYCLE  Command failed with exit code 1.
-drizzle-orm:test:types: ERROR: command finished with error: command (/home/dan/dev/drizzle-orm/drizzle-orm) pnpm run test:types exited (1)
-drizzle-orm:build:  ELIFECYCLE  Command failed.
-//:lint:  ELIFECYCLE  Command failed.
-drizzle-valibot:build: cache miss, executing 06774d0becf4d947
-drizzle-typebox:build: cache miss, executing e3bdb185e6d674a9
-drizzle-zod:build: cache miss, executing c119a2eca839b32d
-drizzle-orm#test:types: command (/home/dan/dev/drizzle-orm/drizzle-orm) pnpm run test:types exited (1)
-
- Tasks:    0 successful, 6 total
-Cached:    0 cached, 6 total
-  Time:    1.588s 
-Failed:    drizzle-orm#test:types
-
- ERROR  run failed: command  exited (1)
- ELIFECYCLE  Command failed with exit code 1.
- ELIFECYCLE  Command failed with exit code 1.

From 8fcd2d41d498116589c401d0bd50fb114628959e Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Fri, 20 Oct 2023 08:09:54 -0400
Subject: [PATCH 59/72] [MySql] Simplification by removing intermediary clases
 and making the queries mutable

---
 drizzle-orm/src/mysql-core/dialect.ts         |  51 ++-
 .../src/mysql-core/query-builders/index.ts    |   1 -
 .../src/mysql-core/query-builders/select.ts   | 150 +++++++-
 .../mysql-core/query-builders/select.types.ts | 287 +++++++-------
 .../query-builders/set-operators.ts           | 364 ------------------
 5 files changed, 309 insertions(+), 544 deletions(-)
 delete mode 100644 drizzle-orm/src/mysql-core/query-builders/set-operators.ts

diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index 4d3edfeca..a41dc6169 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -23,12 +23,7 @@ import { DrizzleError, type Name, ViewBaseConfig } from '../index.ts';
 import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
-import type {
-	MySqlSelectConfig,
-	MySqlSelectJoinConfig,
-	MySqlSetOperationConfig,
-	SelectedFieldsOrdered,
-} from './query-builders/select.types.ts';
+import type { MySqlSelectConfig, MySqlSelectJoinConfig, SelectedFieldsOrdered } from './query-builders/select.types.ts';
 import type { MySqlUpdateConfig } from './query-builders/update.ts';
 import type { MySqlSession } from './session.ts';
 import { MySqlTable } from './table.ts';
@@ -209,6 +204,7 @@ export class MySqlDialect {
 			offset,
 			lockingClause,
 			distinct,
+			setOperators,
 		}: MySqlSelectConfig,
 	): SQL {
 		const fieldsList = fieldsFlat ?? orderSelectedFields<MySqlColumn>(fields);
@@ -336,18 +332,37 @@ export class MySqlDialect {
 			}
 		}
 
-		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
+		const finalQuery =
+			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
+
+		if (setOperators.length > 0) {
+			return this.buildSetOperations(finalQuery, setOperators);
+		}
+
+		return finalQuery;
+	}
+
+	buildSetOperations(leftSelect: SQL, setOperators: MySqlSelectConfig['setOperators']): SQL {
+		const [setOperator, ...rest] = setOperators;
+
+		if (!setOperator) {
+			throw new Error('Cannot pass undefined values to any set operator');
+		}
+
+		if (rest.length === 0) {
+			return this.buildSetOperationQuery({ leftSelect, setOperator });
+		}
+
+		return this.buildSetOperations(
+			this.buildSetOperationQuery({ leftSelect, setOperator }),
+			rest,
+		);
 	}
 
 	buildSetOperationQuery({
-		operator,
-		isAll,
 		leftSelect,
-		rightSelect,
-		limit,
-		orderBy,
-		offset,
-	}: MySqlSetOperationConfig): SQL {
+		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
+	}: { leftSelect: SQL; setOperator: MySqlSelectConfig['setOperators'][number] }): SQL {
 		const leftChunk = sql`(${leftSelect.getSQL()}) `;
 		const rightChunk = sql`(${rightSelect.getSQL()})`;
 
@@ -380,7 +395,7 @@ export class MySqlDialect {
 
 		const limitSql = limit ? sql` limit ${limit}` : undefined;
 
-		const operatorChunk = sql.raw(`${operator} ${isAll ? 'all ' : ''}`);
+		const operatorChunk = sql.raw(`${type} ${isAll ? 'all ' : ''}`);
 
 		const offsetSql = offset ? sql` offset ${offset}` : undefined;
 
@@ -684,6 +699,7 @@ export class MySqlDialect {
 					where,
 					limit,
 					offset,
+					setOperators: [],
 				});
 
 				where = undefined;
@@ -706,6 +722,7 @@ export class MySqlDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		} else {
 			result = this.buildSelectQuery({
@@ -720,6 +737,7 @@ export class MySqlDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		}
 
@@ -974,6 +992,7 @@ export class MySqlDialect {
 					where,
 					limit,
 					offset,
+					setOperators: [],
 				});
 
 				where = undefined;
@@ -995,6 +1014,7 @@ export class MySqlDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		} else {
 			result = this.buildSelectQuery({
@@ -1008,6 +1028,7 @@ export class MySqlDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		}
 
diff --git a/drizzle-orm/src/mysql-core/query-builders/index.ts b/drizzle-orm/src/mysql-core/query-builders/index.ts
index 58d909c22..16f0e1d4d 100644
--- a/drizzle-orm/src/mysql-core/query-builders/index.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/index.ts
@@ -3,5 +3,4 @@ export * from './insert.ts';
 export * from './query-builder.ts';
 export * from './select.ts';
 export * from './select.types.ts';
-export * from './set-operators.ts';
 export * from './update.ts';
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.ts b/drizzle-orm/src/mysql-core/query-builders/select.ts
index 53e51a2ee..aac36dc04 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.ts
@@ -5,6 +5,7 @@ import type { MySqlSession, PreparedQueryConfig, PreparedQueryHKTBase } from '~/
 import type { SubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
 import { MySqlViewBase } from '~/mysql-core/view.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
 	GetSelectTableName,
@@ -13,19 +14,23 @@ import type {
 	JoinType,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import { type Query, SQL } from '~/sql/index.ts';
 import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
-import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } from '~/utils.ts';
+import { applyMixins, getTableColumns, getTableLikeName, haveSameKeys, type ValueOrArray } from '~/utils.ts';
 import { orderSelectedFields } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import { type ColumnsSelection, View } from '~/view.ts';
 import type {
+	AnyMySqlSelect,
 	CreateMySqlSelectFromBuilderMode,
+	GetMySqlSetOperators,
 	LockConfig,
 	LockStrength,
+	MySqlCreateSetOperatorFn,
 	MySqlJoinFn,
 	MySqlSelectConfig,
 	MySqlSelectDynamic,
@@ -33,9 +38,11 @@ import type {
 	MySqlSelectHKTBase,
 	MySqlSelectPrepare,
 	MySqlSelectWithout,
+	MySqlSetOperatorExcludedMethods,
+	MySqlSetOperatorWithResult,
 	SelectedFields,
+	SetOperatorRightSelect,
 } from './select.types.ts';
-import { MySqlSetOperatorBuilder } from './set-operators.ts';
 
 export class MySqlSelectBuilder<
 	TSelection extends SelectedFields | undefined,
@@ -123,18 +130,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends MySqlSetOperatorBuilder<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	PreparedQueryHKTBase,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> {
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'MySqlSelectQueryBuilder';
 
 	override readonly _: {
@@ -175,6 +171,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 			table,
 			fields: { ...fields },
 			distinct,
+			setOperators: [],
 		};
 		this.isPartialSelect = isPartialSelect;
 		this.session = session;
@@ -271,6 +268,61 @@ export abstract class MySqlSelectQueryBuilderBase<
 
 	fullJoin = this.createJoin('full');
 
+	private createSetOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends MySqlSetOperatorWithResult<TResult>>(
+		rightSelection:
+			| ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => MySqlSelectWithout<
+		this,
+		TDynamic,
+		MySqlSetOperatorExcludedMethods,
+		true
+	> {
+		return (rightSelection) => {
+			const rightSelect = (typeof rightSelection === 'function'
+				? rightSelection(getMySqlSetOperators())
+				: rightSelection) as TypedQueryBuilder<
+					any,
+					TResult
+				>;
+
+			if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+
+			this.config.setOperators.push({ type, isAll, rightSelect });
+			return this as any;
+		};
+	}
+
+	union = this.createSetOperator('union', false);
+
+	unionAll = this.createSetOperator('union', true);
+
+	intersect = this.createSetOperator('intersect', false);
+
+	intersectAll = this.createSetOperator('intersect', true);
+
+	except = this.createSetOperator('except', false);
+
+	exceptAll = this.createSetOperator('except', true);
+
+	/** @internal */
+	addSetOperators(setOperators: MySqlSelectConfig['setOperators']): MySqlSelectWithout<
+		this,
+		TDynamic,
+		MySqlSetOperatorExcludedMethods,
+		true
+	> {
+		this.config.setOperators.push(...setOperators);
+		return this as any;
+	}
+
 	where(
 		where: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
 	): MySqlSelectWithout<this, TDynamic, 'where'> {
@@ -340,20 +392,41 @@ export abstract class MySqlSelectQueryBuilderBase<
 					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
 				) as TSelection,
 			);
-			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
 		} else {
-			this.config.orderBy = columns as (MySqlColumn | SQL | SQL.Aliased)[];
+			const orderByArray = columns as (MySqlColumn | SQL | SQL.Aliased)[];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
 		}
 		return this as any;
 	}
 
 	limit(limit: number): MySqlSelectWithout<this, TDynamic, 'limit'> {
-		this.config.limit = limit;
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.limit = limit;
+		} else {
+			this.config.limit = limit;
+		}
 		return this as any;
 	}
 
 	offset(offset: number): MySqlSelectWithout<this, TDynamic, 'offset'> {
-		this.config.offset = offset;
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.offset = offset;
+		} else {
+			this.config.offset = offset;
+		}
 		return this as any;
 	}
 
@@ -474,3 +547,44 @@ export class MySqlSelectBase<
 }
 
 applyMixins(MySqlSelectBase, [QueryPromise]);
+
+function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOperatorFn {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		const setOperators = [rightSelect, ...restSelects].map((select) => ({
+			type,
+			isAll,
+			rightSelect: select as AnyMySqlSelect,
+		}));
+
+		for (const setOperator of setOperators) {
+			if (!haveSameKeys((leftSelect as any).getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+		}
+
+		return (leftSelect as AnyMySqlSelect).addSetOperators(setOperators) as any;
+	};
+}
+
+const getMySqlSetOperators = () => ({
+	union,
+	unionAll,
+	intersect,
+	intersectAll,
+	except,
+	exceptAll,
+});
+
+export const union = createSetOperator('union', false);
+
+export const unionAll = createSetOperator('union', true);
+
+export const intersect = createSetOperator('intersect', false);
+
+export const intersectAll = createSetOperator('intersect', true);
+
+export const except = createSetOperator('except', false);
+
+export const exceptAll = createSetOperator('except', true);
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index e70475dd4..5fc35df99 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -26,7 +26,6 @@ import type { Assume, ValidateShape } from '~/utils.ts';
 import type { ColumnsSelection, View } from '~/view.ts';
 import type { PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
 import type { MySqlSelectBase, MySqlSelectQueryBuilderBase } from './select.ts';
-import type { MySqlSetOperatorBase, MySqlSetOperatorBuilder } from './set-operators.ts';
 
 export interface MySqlSelectJoinConfig {
 	on: SQL | undefined;
@@ -67,6 +66,14 @@ export interface MySqlSelectConfig {
 		config: LockConfig;
 	};
 	distinct?: boolean;
+	setOperators: {
+		rightSelect: TypedQueryBuilder<any, any>;
+		type: SetOperator;
+		isAll: boolean;
+		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+		limit?: number | Placeholder;
+		offset?: number | Placeholder;
+	}[];
 }
 
 export type MySqlJoin<
@@ -195,10 +202,32 @@ export interface MySqlSelectHKT extends MySqlSelectHKTBase {
 	>;
 }
 
+export type MySqlSetOperatorExcludedMethods = Exclude<
+	keyof AnyMySqlSelectQueryBuilder,
+	// Only add the methods that a SetOperator is supposed to have
+	| 'orderBy'
+	| 'limit'
+	| 'offset'
+	| 'union'
+	| 'unionAll'
+	| 'intersect'
+	| 'intersectAll'
+	| 'except'
+	| 'exceptAll'
+	| '_'
+	| 'getSQL'
+	| 'as'
+	| 'addSetOperators'
+	| 'toSQL'
+	| '$dynamic'
+	| 'getSelectedFields'
+>;
+
 export type MySqlSelectWithout<
 	T extends AnyMySqlSelectQueryBuilder,
 	TDynamic extends boolean,
 	K extends keyof T & string,
+	TResetExcluded extends boolean = false,
 > = TDynamic extends true ? T : Omit<
 	MySqlSelectBase<
 		T['_']['tableName'],
@@ -207,11 +236,11 @@ export type MySqlSelectWithout<
 		T['_']['preparedQueryHKT'],
 		T['_']['nullabilityMap'],
 		TDynamic,
-		T['_']['excludedMethods'] | K,
+		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
 		T['_']['result'],
 		T['_']['selectedFields']
 	>,
-	T['_']['excludedMethods'] | K
+	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
 >;
 
 export type MySqlSelectPrepare<T extends AnyMySqlSelect> = PreparedQueryKind<
@@ -269,68 +298,9 @@ export type MySqlSelectQueryBuilder<
 
 export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any, any>;
 
-export type MySqlSelect<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = MySqlSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TNullabilityMap, true, never>;
-
-export type AnyMySqlSelect = MySqlSelectBase<any, any, any, any, any, any, any, any>;
-
-export type MySqlSetOperatorBaseWithResult<T extends any[]> = MySqlSetOperatorInterface<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	T,
-	any
->;
-
-export type SetOperatorRightSelect<
-	TValue extends MySqlSetOperatorBaseWithResult<TResult>,
-	TResult extends any[],
-> = TValue extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
-	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
-			TValueObj,
-			TResult[number],
-			TypedQueryBuilder<any, TValueResult>
-		>
-	: never
-	: TValue;
-
-export type SetOperatorRestSelect<
-	TValue extends readonly MySqlSetOperatorBaseWithResult<TResult>[],
-	TResult extends any[],
-> = TValue extends [infer First, ...infer Rest]
-	? First extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
-		? TValueResult extends Array<infer TValueObj>
-			? Rest extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, any, any>[] ? [
-					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
-					...SetOperatorRestSelect<Rest, TResult>,
-				]
-			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
-		: never
-	: never
-	: TValue;
-
-export interface MySqlSetOperationConfig {
-	fields: Record<string, unknown>;
-	operator: SetOperator;
-	isAll: boolean;
-	leftSelect: AnyMySqlSetOperatorBase;
-	rightSelect: TypedQueryBuilder<any, any[]>;
-	limit?: number | Placeholder;
-	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
-	offset?: number | Placeholder;
-}
+export type AnyMySqlSetOperatorInterface = MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, any>;
 
 export interface MySqlSetOperatorInterface<
-	THKT extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -342,9 +312,8 @@ export interface MySqlSetOperatorInterface<
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	Omit<
-		MySqlSetOperatorBuilder<
-			THKT,
+	Pick<
+		MySqlSelectBase<
 			TTableName,
 			TSelection,
 			TSelectMode,
@@ -355,11 +324,11 @@ export interface MySqlSetOperatorInterface<
 			TResult,
 			TSelectedFields
 		>,
-		'joinsNotNullableMap' | 'session' | 'dialect' | 'createSetOperator'
+		never
 	>
 {
 	_: {
-		readonly hkt: THKT;
+		readonly hkt: MySqlSelectHKT;
 		readonly tableName: TTableName;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
@@ -372,8 +341,32 @@ export interface MySqlSetOperatorInterface<
 	};
 }
 
-export type AnyMySqlSetOperatorBase = MySqlSetOperatorInterface<
+export type MySqlSelectBuilderWithResult<TResult extends any[]> = MySqlSelectQueryBuilderBase<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	TResult,
+	any
+>;
+
+export type MySqlSelectWithResult<TResult extends any[]> = MySqlSelectBase<
+	any,
+	any,
+	any,
+	any,
+	any,
 	any,
+	any,
+	TResult,
+	any
+>;
+
+export type MySqlSetOperatorWithResult<TResult extends any[]> = MySqlSetOperatorInterface<
 	any,
 	any,
 	any,
@@ -381,25 +374,76 @@ export type AnyMySqlSetOperatorBase = MySqlSetOperatorInterface<
 	any,
 	any,
 	any,
+	TResult,
 	any
 >;
 
+export type MySqlSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MySqlSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TNullabilityMap, true, never>;
+
+export type AnyMySqlSelect = MySqlSelectBase<any, any, any, any, any, any, any, any>;
+
+export type MySqlSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = MySqlSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TPreparedQueryHKT,
+	TNullabilityMap,
+	true,
+	MySqlSetOperatorExcludedMethods
+>;
+
+export type SetOperatorRightSelect<
+	TValue extends MySqlSetOperatorWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
+			TValueObj,
+			TResult[number],
+			TypedQueryBuilder<any, TValueResult>
+		>
+	: never
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly MySqlSetOperatorWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+		? TValueResult extends Array<infer TValueObj> ? Rest extends AnyMySqlSetOperatorInterface[] ? [
+					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
+					...SetOperatorRestSelect<Rest, TResult>,
+				]
+			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+		: never
+	: never
+	: TValue;
+
 export type MySqlCreateSetOperatorFn = <
-	THKT extends MySqlSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends MySqlSetOperatorBaseWithResult<TResult>,
-	TRest extends MySqlSetOperatorBaseWithResult<TResult>[],
+	TValue extends MySqlSetOperatorWithResult<TResult>,
+	TRest extends MySqlSetOperatorWithResult<TResult>[],
+	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 >(
 	leftSelect: MySqlSetOperatorInterface<
-		THKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -412,77 +456,28 @@ export type MySqlCreateSetOperatorFn = <
 	>,
 	rightSelect: SetOperatorRightSelect<TValue, TResult>,
 	...restSelects: SetOperatorRestSelect<TRest, TResult>
-) => MySqlSetOperatorBase<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap,
+) => MySqlSelectWithout<
+	MySqlSelectBase<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
 	false,
-	never,
-	TResult,
-	TSelectedFields
->;
-
-export type AnyMySqlSetOperator = MySqlSetOperatorBase<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any
->;
-
-export type MySqlSetOperator<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = MySqlSetOperatorBase<TTableName, TSelection, TSelectMode, TPreparedQueryHKT, TNullabilityMap, true, never>;
-
-export type AnyMySqlSetOperatorBuilder = MySqlSetOperatorBuilder<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any
+	MySqlSetOperatorExcludedMethods,
+	true
 >;
 
-export type MySqlSetOperatorWithout<
-	T extends AnyMySqlSetOperator,
-	TDynamic extends boolean,
-	K extends keyof T & string,
-> = TDynamic extends true ? T
-	: Omit<
-		MySqlSetOperatorBase<
-			T['_']['tableName'],
-			T['_']['selection'],
-			T['_']['selectMode'],
-			T['_']['nullabilityMap'],
-			T['_']['preparedQueryHKT'],
-			TDynamic,
-			T['_']['excludedMethods'] | K,
-			T['_']['result'],
-			T['_']['selectedFields']
-		>,
-		T['_']['excludedMethods'] | K
-	>;
-
-export type MySqlSetOperatorDynamic<T extends AnyMySqlSetOperatorBuilder> = MySqlSetOperatorBase<
-	T['_']['tableName'],
-	T['_']['selection'],
-	T['_']['selectMode'],
-	T['_']['preparedQueryHKT'],
-	T['_']['nullabilityMap'],
-	true,
-	never,
-	T['_']['result'],
-	T['_']['selectedFields']
->;
+export type GetMySqlSetOperators = {
+	union: MySqlCreateSetOperatorFn;
+	intersect: MySqlCreateSetOperatorFn;
+	except: MySqlCreateSetOperatorFn;
+	unionAll: MySqlCreateSetOperatorFn;
+	intersectAll: MySqlCreateSetOperatorFn;
+	exceptAll: MySqlCreateSetOperatorFn;
+};
diff --git a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts b/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
deleted file mode 100644
index 92b5d3680..000000000
--- a/drizzle-orm/src/mysql-core/query-builders/set-operators.ts
+++ /dev/null
@@ -1,364 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import {
-	applyMixins,
-	haveSameKeys,
-	orderSelectedFields,
-	type Placeholder,
-	type Query,
-	QueryPromise,
-	SelectionProxyHandler,
-	type SQL,
-	Subquery,
-	type ValueOrArray,
-} from '~/index.ts';
-import type {
-	MySqlSession,
-	PreparedQueryConfig,
-	PreparedQueryHKTBase,
-	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
-import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	BuildSubquerySelection,
-	JoinNullability,
-	SelectMode,
-	SelectResult,
-	SetOperator,
-} from '~/query-builders/select.types.ts';
-import type { ColumnsSelection } from '~/view.ts';
-import type { MySqlColumn } from '../columns/common.ts';
-import type { MySqlDialect } from '../dialect.ts';
-import type { SubqueryWithSelection } from '../subquery.ts';
-import type {
-	MySqlCreateSetOperatorFn,
-	MySqlSelectHKTBase,
-	MySqlSetOperationConfig,
-	MySqlSetOperatorBaseWithResult,
-	MySqlSetOperatorDynamic,
-	MySqlSetOperatorInterface,
-	MySqlSetOperatorWithout,
-	SetOperatorRightSelect,
-} from './select.types.ts';
-
-const getMySqlSetOperators = () => {
-	return {
-		union,
-		unionAll,
-		intersect,
-		intersectAll,
-		except,
-		exceptAll,
-	};
-};
-
-type MySqlSetOperators = ReturnType<typeof getMySqlSetOperators>;
-
-export abstract class MySqlSetOperatorBuilder<
-	THKT extends MySqlSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<TSelectedFields, TResult> {
-	static readonly [entityKind]: string = 'MySqlSetOperatorBuilder';
-
-	abstract override readonly _: {
-		readonly hkt: THKT;
-		readonly tableName: TTableName;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly preparedQueryHKT: TPreparedQueryHKT;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-	};
-
-	protected abstract joinsNotNullableMap: Record<string, boolean>;
-	protected abstract config: {
-		fields: Record<string, unknown>;
-		limit?: number | Placeholder;
-		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
-		offset?: number | Placeholder;
-	};
-	/* @internal */
-	abstract readonly session: MySqlSession | undefined;
-	protected abstract dialect: MySqlDialect;
-
-	/** @internal */
-	getSetOperatorConfig() {
-		return {
-			session: this.session,
-			dialect: this.dialect,
-			joinsNotNullableMap: this.joinsNotNullableMap,
-			fields: this.config.fields,
-		};
-	}
-
-	private createSetOperator(
-		type: SetOperator,
-		isAll: boolean,
-	): <TValue extends MySqlSetOperatorBaseWithResult<TResult>>(
-		rightSelect:
-			| ((setOperator: MySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>)
-			| SetOperatorRightSelect<TValue, TResult>,
-	) => MySqlSetOperatorBase<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TPreparedQueryHKT,
-		TNullabilityMap,
-		false,
-		never,
-		TResult,
-		TSelectedFields
-	> {
-		return (rightSelect) => {
-			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getMySqlSetOperators()) : rightSelect;
-			return new MySqlSetOperatorBase(type, isAll, this as any, rightSelectOrig as any);
-		};
-	}
-
-	union = this.createSetOperator('union', false);
-
-	unionAll = this.createSetOperator('union', true);
-
-	intersect = this.createSetOperator('intersect', false);
-
-	intersectAll = this.createSetOperator('intersect', true);
-
-	except = this.createSetOperator('except', false);
-
-	exceptAll = this.createSetOperator('except', true);
-}
-
-export interface MySqlSetOperatorBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TDynamic extends boolean = false,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult> {}
-
-export class MySqlSetOperatorBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TPreparedQueryHKT extends PreparedQueryHKTBase,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends MySqlSetOperatorBuilder<
-	MySqlSelectHKTBase,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TPreparedQueryHKT,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> {
-	static readonly [entityKind]: string = 'MySqlSetOperator';
-
-	readonly _: {
-		readonly hkt: MySqlSelectHKTBase;
-		readonly tableName: TTableName;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly preparedQueryHKT: TPreparedQueryHKT;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-	};
-
-	protected joinsNotNullableMap: Record<string, boolean>;
-	protected config: MySqlSetOperationConfig;
-	/* @internal */
-	readonly session: MySqlSession | undefined;
-	protected dialect: MySqlDialect;
-
-	constructor(
-		operator: SetOperator,
-		isAll: boolean,
-		leftSelect: MySqlSetOperatorInterface<
-			MySqlSelectHKTBase,
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap,
-			TDynamic,
-			TExcludedMethods,
-			TResult,
-			TSelectedFields
-		>,
-		rightSelect: TypedQueryBuilder<any, TResult>,
-	) {
-		super();
-
-		const leftSelectedFields = leftSelect.getSelectedFields();
-		const rightSelectedFields = rightSelect.getSelectedFields();
-
-		if (!haveSameKeys(leftSelectedFields, rightSelectedFields)) {
-			throw new Error(
-				'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
-			);
-		}
-
-		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
-
-		this._ = {
-			selectedFields: fields,
-		} as this['_'];
-
-		this.session = session;
-		this.dialect = dialect;
-		this.joinsNotNullableMap = joinsNotNullableMap;
-		this.config = {
-			fields,
-			operator,
-			isAll,
-			leftSelect,
-			rightSelect,
-		};
-	}
-
-	orderBy(
-		...columns:
-			| [(aliases: TSelection) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
-			| (MySqlColumn | SQL | SQL.Aliased)[]
-	): MySqlSetOperatorWithout<this, TDynamic, 'orderBy'> {
-		if (typeof columns[0] === 'function') {
-			const orderBy = columns[0](
-				new Proxy(
-					this.config.fields,
-					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
-				) as TSelection,
-			);
-			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
-		} else {
-			this.config.orderBy = columns as (MySqlColumn | SQL | SQL.Aliased)[];
-		}
-		return this as any;
-	}
-
-	limit(limit: number): MySqlSetOperatorWithout<this, TDynamic, 'limit'> {
-		this.config.limit = limit;
-		return this as any;
-	}
-
-	offset(offset: number | Placeholder): MySqlSetOperatorWithout<this, TDynamic, 'offset'> {
-		this.config.offset = offset;
-		return this as any;
-	}
-
-	/** @internal */
-	override getSQL(): SQL<unknown> {
-		return this.dialect.buildSetOperationQuery(this.config);
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	prepare() {
-		if (!this.session) {
-			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
-		}
-		const fieldsList = orderSelectedFields<MySqlColumn>(this.config.fields);
-		const query = this.session.prepareQuery<
-			PreparedQueryConfig & { execute: TResult },
-			TPreparedQueryHKT
-		>(this.dialect.sqlToQuery(this.getSQL()), fieldsList);
-		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query as PreparedQueryKind<
-			TPreparedQueryHKT,
-			PreparedQueryConfig & {
-				execute: TResult;
-				iterator: SelectResult<TSelection, TSelectMode, TNullabilityMap>;
-			},
-			true
-		>;
-	}
-
-	execute = ((placeholderValues) => {
-		return this.prepare().execute(placeholderValues);
-	}) as ReturnType<this['prepare']>['execute'];
-
-	private createIterator = (): ReturnType<this['prepare']>['iterator'] => {
-		const self = this;
-		return async function*(placeholderValues) {
-			console.log('placeholderValues', placeholderValues);
-			yield* self.prepare().iterator(placeholderValues);
-		};
-	};
-
-	iterator = this.createIterator();
-
-	as<TAlias extends string>(
-		alias: TAlias,
-	): SubqueryWithSelection<TSelectedFields, TAlias> {
-		return new Proxy(
-			new Subquery(this.getSQL(), this.config.fields, alias),
-			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<TSelectedFields, TAlias>;
-	}
-
-	$dynamic(): MySqlSetOperatorDynamic<this> {
-		return this as any;
-	}
-}
-
-applyMixins(MySqlSetOperatorBase, [QueryPromise]);
-
-function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOperatorFn {
-	return (leftSelect, rightSelect, ...restSelects) => {
-		if (restSelects.length === 0) {
-			return new MySqlSetOperatorBase(type, isAll, leftSelect, rightSelect as any) as any;
-		}
-
-		const [select, ...rest] = restSelects;
-		if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-		return createSetOperator(type, isAll)(
-			new MySqlSetOperatorBase(type, isAll, leftSelect, rightSelect as any),
-			select as any,
-			...rest,
-		);
-	};
-}
-
-export const union = createSetOperator('union', false);
-
-export const unionAll = createSetOperator('union', true);
-
-export const intersect = createSetOperator('intersect', false);
-
-export const intersectAll = createSetOperator('intersect', true);
-
-export const except = createSetOperator('except', false);
-
-export const exceptAll = createSetOperator('except', true);

From c8117b1a7ff66a10a594bf81a77fff530ec88c98 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Fri, 20 Oct 2023 18:27:04 -0400
Subject: [PATCH 60/72] [Pg] Simplification by removing intermediary clases and
 making the queries mutable

---
 drizzle-orm/src/mysql-core/dialect.ts         |   1 +
 .../mysql-core/query-builders/select.types.ts |  38 +-
 drizzle-orm/src/pg-core/dialect.ts            |  44 ++-
 .../src/pg-core/query-builders/index.ts       |   1 -
 .../src/pg-core/query-builders/select.ts      | 149 ++++++-
 .../pg-core/query-builders/select.types.ts    | 265 ++++++-------
 .../pg-core/query-builders/set-operators.ts   | 371 ------------------
 7 files changed, 291 insertions(+), 578 deletions(-)
 delete mode 100644 drizzle-orm/src/pg-core/query-builders/set-operators.ts

diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index a41dc6169..057565e0f 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -353,6 +353,7 @@ export class MySqlDialect {
 			return this.buildSetOperationQuery({ leftSelect, setOperator });
 		}
 
+    // Some recursive magic here
 		return this.buildSetOperations(
 			this.buildSetOperationQuery({ leftSelect, setOperator }),
 			rest,
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index 5fc35df99..1acb4a5e5 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -91,14 +91,14 @@ export type MySqlJoin<
 				T['_']['selection'],
 				TJoinedName,
 				TJoinedTable extends MySqlTable ? TJoinedTable['_']['columns']
-					: TJoinedTable extends Subquery | View ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
+					: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
 					: never,
 				T['_']['selectMode']
 			>,
 			T['_']['selectMode'] extends 'partial' ? T['_']['selectMode'] : 'multiple',
 			T['_']['preparedQueryHKT'],
 			AppendToNullabilityMap<T['_']['nullabilityMap'], TJoinedName, TJoinType>,
-			T['_']['dynamic'],
+			TDynamic,
 			T['_']['excludedMethods']
 		>,
 		TDynamic,
@@ -229,7 +229,8 @@ export type MySqlSelectWithout<
 	K extends keyof T & string,
 	TResetExcluded extends boolean = false,
 > = TDynamic extends true ? T : Omit<
-	MySqlSelectBase<
+	MySqlSelectKind<
+    T['_']['hkt'],
 		T['_']['tableName'],
 		T['_']['selection'],
 		T['_']['selectMode'],
@@ -277,12 +278,12 @@ export type CreateMySqlSelectFromBuilderMode<
 export type MySqlSelectQueryBuilder<
 	THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT,
 	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelection extends ColumnsSelection = ColumnsSelection,
 	TSelectMode extends SelectMode = SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 	TResult extends any[] = unknown[],
-	TSelectedFields extends ColumnsSelection = Record<string, any>,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
 > = MySqlSelectQueryBuilderBase<
 	THKT,
 	TTableName,
@@ -296,7 +297,7 @@ export type MySqlSelectQueryBuilder<
 	TSelectedFields
 >;
 
-export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any, any>;
+export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
 
 export type AnyMySqlSetOperatorInterface = MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, any>;
 
@@ -341,31 +342,6 @@ export interface MySqlSetOperatorInterface<
 	};
 }
 
-export type MySqlSelectBuilderWithResult<TResult extends any[]> = MySqlSelectQueryBuilderBase<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	TResult,
-	any
->;
-
-export type MySqlSelectWithResult<TResult extends any[]> = MySqlSelectBase<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	TResult,
-	any
->;
-
 export type MySqlSetOperatorWithResult<TResult extends any[]> = MySqlSetOperatorInterface<
 	any,
 	any,
diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 851dff453..64d2eface 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -8,7 +8,6 @@ import type {
 	PgDeleteConfig,
 	PgInsertConfig,
 	PgSelectJoinConfig,
-	PgSetOperationConfig,
 	PgUpdateConfig,
 } from '~/pg-core/query-builders/index.ts';
 import type { PgSelectConfig, SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
@@ -209,6 +208,7 @@ export class PgDialect {
 			offset,
 			lockingClause,
 			distinct,
+			setOperators,
 		}: PgSelectConfig,
 	): SQL {
 		const fieldsList = fieldsFlat ?? orderSelectedFields<PgColumn>(fields);
@@ -352,19 +352,38 @@ export class PgDialect {
 			}
 			lockingClauseSql.append(clauseSql);
 		}
+		const finalQuery =
+			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
 
-		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
+		if (setOperators.length > 0) {
+			return this.buildSetOperations(finalQuery, setOperators);
+		}
+
+		return finalQuery;
+	}
+
+	buildSetOperations(leftSelect: SQL, setOperators: PgSelectConfig['setOperators']): SQL {
+		const [setOperator, ...rest] = setOperators;
+
+		if (!setOperator) {
+			throw new Error('Cannot pass undefined values to any set operator');
+		}
+
+		if (rest.length === 0) {
+			return this.buildSetOperationQuery({ leftSelect, setOperator });
+		}
+
+		// Some recursive magic here
+		return this.buildSetOperations(
+			this.buildSetOperationQuery({ leftSelect, setOperator }),
+			rest,
+		);
 	}
 
 	buildSetOperationQuery({
-		operator,
-		isAll,
 		leftSelect,
-		rightSelect,
-		limit,
-		orderBy,
-		offset,
-	}: PgSetOperationConfig): SQL {
+		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
+	}: { leftSelect: SQL; setOperator: PgSelectConfig['setOperators'][number] }): SQL {
 		const leftChunk = sql`(${leftSelect.getSQL()}) `;
 		const rightChunk = sql`(${rightSelect.getSQL()})`;
 
@@ -373,7 +392,7 @@ export class PgDialect {
 			const orderByValues: (SQL<unknown> | Name)[] = [];
 
 			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
-			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			// which is invalid Sql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
 			for (const singleOrderBy of orderBy) {
 				if (is(singleOrderBy, PgColumn)) {
 					orderByValues.push(sql.identifier(singleOrderBy.name));
@@ -397,7 +416,7 @@ export class PgDialect {
 
 		const limitSql = limit ? sql` limit ${limit}` : undefined;
 
-		const operatorChunk = sql.raw(`${operator} ${isAll ? 'all ' : ''}`);
+		const operatorChunk = sql.raw(`${type} ${isAll ? 'all ' : ''}`);
 
 		const offsetSql = offset ? sql` offset ${offset}` : undefined;
 
@@ -1260,6 +1279,7 @@ export class PgDialect {
 					limit,
 					offset,
 					orderBy,
+					setOperators: [],
 				});
 
 				where = undefined;
@@ -1282,6 +1302,7 @@ export class PgDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		} else {
 			result = this.buildSelectQuery({
@@ -1296,6 +1317,7 @@ export class PgDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		}
 
diff --git a/drizzle-orm/src/pg-core/query-builders/index.ts b/drizzle-orm/src/pg-core/query-builders/index.ts
index fb3dd5931..c4821e51d 100644
--- a/drizzle-orm/src/pg-core/query-builders/index.ts
+++ b/drizzle-orm/src/pg-core/query-builders/index.ts
@@ -4,5 +4,4 @@ export * from './query-builder.ts';
 export * from './refresh-materialized-view.ts';
 export * from './select.ts';
 export * from './select.types.ts';
-export * from './set-operators.ts';
 export * from './update.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index 0874ef774..f9e4b41b7 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -5,6 +5,7 @@ import type { PgSession, PreparedQueryConfig } from '~/pg-core/session.ts';
 import type { SubqueryWithSelection } from '~/pg-core/subquery.ts';
 import type { PgTable } from '~/pg-core/table.ts';
 import { PgViewBase } from '~/pg-core/view.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
 	GetSelectTableName,
@@ -13,20 +14,24 @@ import type {
 	JoinType,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import { type Placeholder, type Query, SQL, type SQLWrapper } from '~/sql/index.ts';
 import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
 import { tracer } from '~/tracing.ts';
-import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } from '~/utils.ts';
+import { applyMixins, getTableColumns, getTableLikeName, haveSameKeys, type ValueOrArray } from '~/utils.ts';
 import { orderSelectedFields } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import { type ColumnsSelection, View } from '~/view.ts';
 import type {
+	AnyPgSelect,
 	CreatePgSelectFromBuilderMode,
+	GetPgSetOperators,
 	LockConfig,
 	LockStrength,
+	PgCreateSetOperatorFn,
 	PgJoinFn,
 	PgSelectConfig,
 	PgSelectDynamic,
@@ -34,9 +39,11 @@ import type {
 	PgSelectHKTBase,
 	PgSelectPrepare,
 	PgSelectWithout,
+	PgSetOperatorExcludedMethods,
+	PgSetOperatorWithResult,
 	SelectedFields,
+	SetOperatorRightSelect,
 } from './select.types.ts';
-import { PgSetOperatorBuilder } from './set-operators.ts';
 
 export class PgSelectBuilder<
 	TSelection extends SelectedFields | undefined,
@@ -129,17 +136,7 @@ export abstract class PgSelectQueryBuilderBase<
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends PgSetOperatorBuilder<
-	THKT,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> {
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'PgSelectQueryBuilder';
 
 	override readonly _: {
@@ -180,6 +177,7 @@ export abstract class PgSelectQueryBuilderBase<
 			table,
 			fields: { ...fields },
 			distinct,
+			setOperators: [],
 		};
 		this.isPartialSelect = isPartialSelect;
 		this.session = session;
@@ -301,6 +299,61 @@ export abstract class PgSelectQueryBuilderBase<
 	 */
 	fullJoin = this.createJoin('full');
 
+	private createSetOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends PgSetOperatorWithResult<TResult>>(
+		rightSelection:
+			| ((setOperators: GetPgSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => PgSelectWithout<
+		this,
+		TDynamic,
+		PgSetOperatorExcludedMethods,
+		true
+	> {
+		return (rightSelection) => {
+			const rightSelect = (typeof rightSelection === 'function'
+				? rightSelection(getPgSetOperators())
+				: rightSelection) as TypedQueryBuilder<
+					any,
+					TResult
+				>;
+
+			if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+
+			this.config.setOperators.push({ type, isAll, rightSelect });
+			return this as any;
+		};
+	}
+
+	union = this.createSetOperator('union', false);
+
+	unionAll = this.createSetOperator('union', true);
+
+	intersect = this.createSetOperator('intersect', false);
+
+	intersectAll = this.createSetOperator('intersect', true);
+
+	except = this.createSetOperator('except', false);
+
+	exceptAll = this.createSetOperator('except', true);
+
+	/** @internal */
+	addSetOperators(setOperators: PgSelectConfig['setOperators']): PgSelectWithout<
+		this,
+		TDynamic,
+		PgSetOperatorExcludedMethods,
+		true
+	> {
+		this.config.setOperators.push(...setOperators);
+		return this as any;
+	}
+
 	/**
 	 * Specify a condition to narrow the result set. Multiple
 	 * conditions can be combined with the `and` and `or`
@@ -422,9 +475,22 @@ export abstract class PgSelectQueryBuilderBase<
 					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
 				) as TSelection,
 			);
-			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
 		} else {
-			this.config.orderBy = columns as (PgColumn | SQL | SQL.Aliased)[];
+			const orderByArray = columns as (PgColumn | SQL | SQL.Aliased)[];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
 		}
 		return this as any;
 	}
@@ -443,7 +509,11 @@ export abstract class PgSelectQueryBuilderBase<
 	 * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT | Postgres LIMIT documentation}
 	 */
 	limit(limit: number | Placeholder): PgSelectWithout<this, TDynamic, 'limit'> {
-		this.config.limit = limit;
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.limit = limit;
+		} else {
+			this.config.limit = limit;
+		}
 		return this as any;
 	}
 
@@ -459,7 +529,11 @@ export abstract class PgSelectQueryBuilderBase<
 	 * ```
 	 */
 	offset(offset: number | Placeholder): PgSelectWithout<this, TDynamic, 'offset'> {
-		this.config.offset = offset;
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.offset = offset;
+		} else {
+			this.config.offset = offset;
+		}
 		return this as any;
 	}
 
@@ -589,3 +663,44 @@ export class PgSelectBase<
 }
 
 applyMixins(PgSelectBase, [QueryPromise]);
+
+function createSetOperator(type: SetOperator, isAll: boolean): PgCreateSetOperatorFn {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		const setOperators = [rightSelect, ...restSelects].map((select) => ({
+			type,
+			isAll,
+			rightSelect: select as AnyPgSelect,
+		}));
+
+		for (const setOperator of setOperators) {
+			if (!haveSameKeys((leftSelect as any).getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+		}
+
+		return (leftSelect as AnyPgSelect).addSetOperators(setOperators) as any;
+	};
+}
+
+const getPgSetOperators = () => ({
+	union,
+	unionAll,
+	intersect,
+	intersectAll,
+	except,
+	exceptAll,
+});
+
+export const union = createSetOperator('union', false);
+
+export const unionAll = createSetOperator('union', true);
+
+export const intersect = createSetOperator('intersect', false);
+
+export const intersectAll = createSetOperator('intersect', true);
+
+export const except = createSetOperator('except', false);
+
+export const exceptAll = createSetOperator('except', true);
diff --git a/drizzle-orm/src/pg-core/query-builders/select.types.ts b/drizzle-orm/src/pg-core/query-builders/select.types.ts
index 832f2c37a..4d8ba939f 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.types.ts
@@ -26,7 +26,6 @@ import type { Assume, ValidateShape, ValueOrArray } from '~/utils.ts';
 import type { ColumnsSelection, View } from '~/view.ts';
 import type { PreparedQuery, PreparedQueryConfig } from '../session.ts';
 import type { PgSelectBase, PgSelectQueryBuilderBase } from './select.ts';
-import type { PgSetOperatorBase, PgSetOperatorBuilder } from './set-operators.ts';
 
 export interface PgSelectJoinConfig {
 	on: SQL | undefined;
@@ -70,10 +69,18 @@ export interface PgSelectConfig {
 	distinct?: boolean | {
 		on: (PgColumn | SQLWrapper)[];
 	};
+	setOperators: {
+		rightSelect: TypedQueryBuilder<any, any>;
+		type: SetOperator;
+		isAll: boolean;
+		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+		limit?: number | Placeholder;
+		offset?: number | Placeholder;
+	}[];
 }
 
 export type PgJoin<
-	T extends AnyPgSelectQueryBuilderBase,
+	T extends AnyPgSelectQueryBuilder,
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
 	TJoinedTable extends PgTable | Subquery | PgViewBase | SQL,
@@ -102,7 +109,7 @@ export type PgJoin<
 	: never;
 
 export type PgJoinFn<
-	T extends AnyPgSelectQueryBuilderBase,
+	T extends AnyPgSelectQueryBuilder,
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
 > = <
@@ -204,10 +211,32 @@ export type CreatePgSelectFromBuilderMode<
 > = TBuilderMode extends 'db' ? PgSelectBase<TTableName, TSelection, TSelectMode>
 	: PgSelectQueryBuilderBase<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
 
+export type PgSetOperatorExcludedMethods = Exclude<
+	keyof AnyPgSelectQueryBuilder,
+	// Only add the methods that a SetOperator is supposed to have
+	| 'orderBy'
+	| 'limit'
+	| 'offset'
+	| 'union'
+	| 'unionAll'
+	| 'intersect'
+	| 'intersectAll'
+	| 'except'
+	| 'exceptAll'
+	| '_'
+	| 'getSQL'
+	| 'as'
+	| 'addSetOperators'
+	| 'toSQL'
+	| '$dynamic'
+	| 'getSelectedFields'
+>;
+
 export type PgSelectWithout<
-	T extends AnyPgSelectQueryBuilderBase,
+	T extends AnyPgSelectQueryBuilder,
 	TDynamic extends boolean,
 	K extends keyof T & string,
+	TResetExcluded extends boolean = false,
 > = TDynamic extends true ? T : Omit<
 	PgSelectKind<
 		T['_']['hkt'],
@@ -216,11 +245,11 @@ export type PgSelectWithout<
 		T['_']['selectMode'],
 		T['_']['nullabilityMap'],
 		TDynamic,
-		T['_']['excludedMethods'] | K,
+		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
 		T['_']['result'],
 		T['_']['selectedFields']
 	>,
-	T['_']['excludedMethods'] | K
+	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
 >;
 
 export type PgSelectPrepare<T extends AnyPgSelect> = PreparedQuery<
@@ -229,7 +258,7 @@ export type PgSelectPrepare<T extends AnyPgSelect> = PreparedQuery<
 	}
 >;
 
-export type PgSelectDynamic<T extends AnyPgSelectQueryBuilderBase> = PgSelectKind<
+export type PgSelectDynamic<T extends AnyPgSelectQueryBuilder> = PgSelectKind<
 	T['_']['hkt'],
 	T['_']['tableName'],
 	T['_']['selection'],
@@ -261,69 +290,11 @@ export type PgSelectQueryBuilder<
 	TSelectedFields
 >;
 
-export type AnyPgSelectQueryBuilderBase = PgSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
-
-export type PgSelect<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = PgSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
-
-export type AnyPgSelect = PgSelectBase<any, any, any, any, any, any, any, any>;
+export type AnyPgSelectQueryBuilder = PgSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
 
-export type PgSetOperatorBaseWithResult<T extends any[]> = PgSetOperatorInterface<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	T,
-	any
->;
-
-export type SetOperatorRightSelect<
-	TValue extends PgSetOperatorBaseWithResult<TResult>,
-	TResult extends any[],
-> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
-	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
-			TValueObj,
-			TResult[number],
-			TypedQueryBuilder<any, TValueResult>
-		>
-	: never
-	: TValue;
-
-export type SetOperatorRestSelect<
-	TValue extends readonly PgSetOperatorBaseWithResult<TResult>[],
-	TResult extends any[],
-> = TValue extends [infer First, ...infer Rest]
-	? First extends PgSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
-		? TValueResult extends Array<infer TValueObj>
-			? Rest extends PgSetOperatorInterface<any, any, any, any, any, any, any, any, any>[] ? [
-					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
-					...SetOperatorRestSelect<Rest, TResult>,
-				]
-			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
-		: never
-	: never
-	: TValue;
-
-export interface PgSetOperationConfig {
-	fields: Record<string, unknown>;
-	operator: SetOperator;
-	isAll: boolean;
-	leftSelect: AnyPgSetOperatorBase;
-	rightSelect: TypedQueryBuilder<any, any[]>;
-	limit?: number | Placeholder;
-	orderBy?: (PgColumn | SQL | SQL.Aliased)[];
-	offset?: number | Placeholder;
-}
+export type AnyPgSetOperatorInterface = PgSetOperatorInterface<any, any, any, any, any, any, any, any>;
 
 export interface PgSetOperatorInterface<
-	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -334,9 +305,8 @@ export interface PgSetOperatorInterface<
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	Omit<
-		PgSetOperatorBuilder<
-			THKT,
+	Pick<
+		PgSelectBase<
 			TTableName,
 			TSelection,
 			TSelectMode,
@@ -346,11 +316,11 @@ export interface PgSetOperatorInterface<
 			TResult,
 			TSelectedFields
 		>,
-		'joinsNotNullableMap' | 'session' | 'dialect' | 'createSetOperator'
+		never
 	>
 {
 	_: {
-		readonly hkt: THKT;
+		readonly hkt: PgSelectHKT;
 		readonly tableName: TTableName;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
@@ -362,33 +332,80 @@ export interface PgSetOperatorInterface<
 	};
 }
 
-export type AnyPgSetOperatorBase = PgSetOperatorInterface<
-	any,
-	any,
+export type PgSetOperatorWithResult<TResult extends any[]> = PgSetOperatorInterface<
 	any,
 	any,
 	any,
 	any,
 	any,
 	any,
+	TResult,
 	any
 >;
 
+export type PgSelect<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgSelectBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnyPgSelect = PgSelectBase<any, any, any, any, any, any, any, any>;
+
+export type PgSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = PgSelectBase<
+	TTableName,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	PgSetOperatorExcludedMethods
+>;
+
+export type SetOperatorRightSelect<
+	TValue extends PgSetOperatorWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
+	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
+			TValueObj,
+			TResult[number],
+			TypedQueryBuilder<any, TValueResult>
+		>
+	: never
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly PgSetOperatorWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
+		? TValueResult extends Array<infer TValueObj> ? Rest extends AnyPgSetOperatorInterface[] ? [
+					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
+					...SetOperatorRestSelect<Rest, TResult>,
+				]
+			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+		: never
+	: never
+	: TValue;
+
 export type PgCreateSetOperatorFn = <
-	THKT extends PgSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends PgSetOperatorBaseWithResult<TResult>,
-	TRest extends PgSetOperatorBaseWithResult<TResult>[],
+	TValue extends PgSetOperatorWithResult<TResult>,
+	TRest extends PgSetOperatorWithResult<TResult>[],
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 >(
 	leftSelect: PgSetOperatorInterface<
-		THKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -400,73 +417,27 @@ export type PgCreateSetOperatorFn = <
 	>,
 	rightSelect: SetOperatorRightSelect<TValue, TResult>,
 	...restSelects: SetOperatorRestSelect<TRest, TResult>
-) => PgSetOperatorBase<
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
+) => PgSelectWithout<
+	PgSelectBase<
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
 	false,
-	never,
-	TResult,
-	TSelectedFields
+	PgSetOperatorExcludedMethods,
+	true
 >;
 
-export type AnyPgSetOperator = PgSetOperatorBase<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any
->;
-
-export type PgSetOperator<
-	TTableName extends string | undefined = string | undefined,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = PgSetOperatorBase<TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
-
-export type AnyPgSetOperatorBuilder = PgSetOperatorBuilder<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any
->;
-
-export type PgSetOperatorWithout<
-	T extends AnyPgSetOperator,
-	TDynamic extends boolean,
-	K extends keyof T & string,
-> = TDynamic extends true ? T
-	: Omit<
-		PgSetOperatorBase<
-			T['_']['tableName'],
-			T['_']['selection'],
-			T['_']['selectMode'],
-			T['_']['nullabilityMap'],
-			TDynamic,
-			T['_']['excludedMethods'] | K,
-			T['_']['result'],
-			T['_']['selectedFields']
-		>,
-		T['_']['excludedMethods'] | K
-	>;
-
-export type PgSetOperatorDynamic<T extends AnyPgSetOperatorBuilder> = PgSetOperatorBase<
-	T['_']['tableName'],
-	T['_']['selection'],
-	T['_']['selectMode'],
-	T['_']['nullabilityMap'],
-	true,
-	never,
-	T['_']['result'],
-	T['_']['selectedFields']
->;
+export type GetPgSetOperators = {
+	union: PgCreateSetOperatorFn;
+	intersect: PgCreateSetOperatorFn;
+	except: PgCreateSetOperatorFn;
+	unionAll: PgCreateSetOperatorFn;
+	intersectAll: PgCreateSetOperatorFn;
+	exceptAll: PgCreateSetOperatorFn;
+};
diff --git a/drizzle-orm/src/pg-core/query-builders/set-operators.ts b/drizzle-orm/src/pg-core/query-builders/set-operators.ts
deleted file mode 100644
index 27c024f1c..000000000
--- a/drizzle-orm/src/pg-core/query-builders/set-operators.ts
+++ /dev/null
@@ -1,371 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import {
-	orderSelectedFields,
-	type Placeholder,
-	type Query,
-	SelectionProxyHandler,
-	type SQL,
-	Subquery,
-	type ValueOrArray,
-} from '~/index.ts';
-import type { PgSession, PreparedQuery, PreparedQueryConfig } from '~/pg-core/session.ts';
-import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	BuildSubquerySelection,
-	JoinNullability,
-	SelectMode,
-	SelectResult,
-	SetOperator,
-} from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import { tracer } from '~/tracing.ts';
-import { applyMixins, haveSameKeys } from '~/utils.ts';
-import type { ColumnsSelection } from '~/view.ts';
-import type { PgColumn } from '../columns/common.ts';
-import type { PgDialect } from '../dialect.ts';
-import type { SubqueryWithSelection } from '../subquery.ts';
-import type {
-	PgCreateSetOperatorFn,
-	PgSelectHKTBase,
-	PgSetOperationConfig,
-	PgSetOperatorBaseWithResult,
-	PgSetOperatorDynamic,
-	PgSetOperatorInterface,
-	PgSetOperatorWithout,
-	SetOperatorRightSelect,
-} from './select.types.ts';
-
-const getPgSetOperators = () => {
-	return {
-		union,
-		unionAll,
-		intersect,
-		intersectAll,
-		except,
-		exceptAll,
-	};
-};
-
-type PgSetOperators = ReturnType<typeof getPgSetOperators>;
-
-export abstract class PgSetOperatorBuilder<
-	THKT extends PgSelectHKTBase,
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<TSelectedFields, TResult> {
-	static readonly [entityKind]: string = 'PgSetOperatorBuilder';
-
-	abstract override readonly _: {
-		readonly hkt: THKT;
-		readonly tableName: TTableName;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-	};
-
-	protected abstract joinsNotNullableMap: Record<string, boolean>;
-	protected abstract config: {
-		fields: Record<string, unknown>;
-		limit?: number | Placeholder;
-		orderBy?: (PgColumn | SQL | SQL.Aliased)[];
-		offset?: number | Placeholder;
-	};
-	/* @internal */
-	protected abstract readonly session: PgSession | undefined;
-	protected abstract dialect: PgDialect;
-
-	/** @internal */
-	getSetOperatorConfig() {
-		return {
-			session: this.session,
-			dialect: this.dialect,
-			joinsNotNullableMap: this.joinsNotNullableMap,
-			fields: this.config.fields,
-		};
-	}
-
-	private setOperator(
-		type: SetOperator,
-		isAll: boolean,
-	): <TValue extends PgSetOperatorBaseWithResult<TResult>>(
-		rightSelect:
-			| ((setOperator: PgSetOperators) => SetOperatorRightSelect<TValue, TResult>)
-			| SetOperatorRightSelect<TValue, TResult>,
-	) => PgSetOperatorBase<
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		false,
-		never,
-		TResult,
-		TSelectedFields
-	> {
-		return (rightSelect) => {
-			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getPgSetOperators()) : rightSelect;
-
-			return new PgSetOperatorBase(type, isAll, this, rightSelectOrig as any) as any;
-		};
-	}
-
-	union = this.setOperator('union', false);
-
-	unionAll = this.setOperator('union', true);
-
-	intersect = this.setOperator('intersect', false);
-
-	intersectAll = this.setOperator('intersect', true);
-
-	except = this.setOperator('except', false);
-
-	exceptAll = this.setOperator('except', true);
-}
-
-export interface PgSetOperatorBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	PgSetOperatorBuilder<
-		PgSelectHKTBase,
-		TTableName,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		TDynamic,
-		TExcludedMethods,
-		TResult,
-		TSelectedFields
-	>,
-	QueryPromise<TResult>
-{}
-
-export class PgSetOperatorBase<
-	TTableName extends string | undefined,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends PgSetOperatorBuilder<
-	PgSelectHKTBase,
-	TTableName,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> {
-	static readonly [entityKind]: string = 'PgSetOperator';
-
-	readonly _: {
-		readonly hkt: PgSelectHKTBase;
-		readonly tableName: TTableName;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-	};
-
-	protected joinsNotNullableMap: Record<string, boolean>;
-	protected config: PgSetOperationConfig;
-	/* @internal */
-	readonly session: PgSession | undefined;
-	protected dialect: PgDialect;
-
-	constructor(
-		operator: SetOperator,
-		isAll: boolean,
-		leftSelect: PgSetOperatorInterface<
-			PgSelectHKTBase,
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TNullabilityMap,
-			TDynamic,
-			TExcludedMethods,
-			TResult,
-			TSelectedFields
-		>,
-		rightSelect: TypedQueryBuilder<any, TResult>,
-	) {
-		super();
-
-		const leftSelectedFields = leftSelect.getSelectedFields();
-		const rightSelectedFields = rightSelect.getSelectedFields();
-
-		if (!haveSameKeys(leftSelectedFields, rightSelectedFields)) {
-			throw new Error(
-				'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
-			);
-		}
-
-		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
-
-		this._ = {
-			selectedFields: fields as TSelectedFields,
-		} as this['_'];
-
-		this.session = session;
-		this.dialect = dialect;
-		this.joinsNotNullableMap = joinsNotNullableMap;
-		this.config = {
-			fields,
-			operator,
-			isAll,
-			leftSelect,
-			rightSelect,
-		};
-	}
-
-	orderBy(
-		builder: (aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>,
-	): PgSetOperatorWithout<this, TDynamic, 'orderBy'>;
-	orderBy(...columns: (PgColumn | SQL | SQL.Aliased)[]): PgSetOperatorWithout<this, TDynamic, 'orderBy'>;
-	orderBy(
-		...columns:
-			| [(aliases: TSelection) => ValueOrArray<PgColumn | SQL | SQL.Aliased>]
-			| (PgColumn | SQL | SQL.Aliased)[]
-	): PgSetOperatorWithout<this, TDynamic, 'orderBy'> {
-		if (typeof columns[0] === 'function') {
-			const orderBy = columns[0](
-				new Proxy(
-					this.config.fields,
-					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
-				) as TSelection,
-			);
-			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
-		} else {
-			this.config.orderBy = columns as (PgColumn | SQL | SQL.Aliased)[];
-		}
-		return this as any;
-	}
-
-	limit(limit: number): PgSetOperatorWithout<this, TDynamic, 'limit'> {
-		this.config.limit = limit;
-		return this as any;
-	}
-
-	offset(offset: number | Placeholder): PgSetOperatorWithout<this, TDynamic, 'offset'> {
-		this.config.offset = offset;
-		return this as any;
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	override getSQL(): SQL<unknown> {
-		return this.dialect.buildSetOperationQuery(this.config);
-	}
-
-	private _prepare(name?: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TResult;
-		}
-	> {
-		const { session, joinsNotNullableMap, config: { fields }, dialect } = this;
-		if (!session) {
-			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
-		}
-		return tracer.startActiveSpan('drizzle.prepareQuery', () => {
-			const fieldsList = orderSelectedFields<PgColumn>(fields);
-			const query = session.prepareQuery<
-				PreparedQueryConfig & { execute: TResult }
-			>(dialect.sqlToQuery(this.getSQL()), fieldsList, name);
-			query.joinsNotNullableMap = joinsNotNullableMap;
-			return query;
-		});
-	}
-
-	/**
-	 * Create a prepared statement for this query. This allows
-	 * the database to remember this query for the given session
-	 * and call it by name, rather than specifying the full query.
-	 *
-	 * {@link https://www.postgresql.org/docs/current/sql-prepare.html|Postgres prepare documentation}
-	 */
-	prepare(name: string): PreparedQuery<
-		PreparedQueryConfig & {
-			execute: TResult;
-		}
-	> {
-		return this._prepare(name);
-	}
-
-	execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
-		return tracer.startActiveSpan('drizzle.operation', () => {
-			return this._prepare().execute(placeholderValues);
-		});
-	};
-
-	as<TAlias extends string>(
-		alias: TAlias,
-	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias> {
-		return new Proxy(
-			new Subquery(this.getSQL(), this.config.fields, alias),
-			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
-	}
-
-	$dynamic(): PgSetOperatorDynamic<this> {
-		return this as any;
-	}
-}
-
-applyMixins(PgSetOperatorBase, [QueryPromise]);
-
-function setOperator(type: SetOperator, isAll: boolean): PgCreateSetOperatorFn {
-	return (leftSelect, rightSelect, ...restSelects) => {
-		if (restSelects.length === 0) {
-			return new PgSetOperatorBase(type, isAll, leftSelect, rightSelect as any) as any;
-		}
-
-		const [select, ...rest] = restSelects;
-		if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-		return setOperator(type, isAll)(
-			new PgSetOperatorBase(type, isAll, leftSelect, rightSelect as any),
-			select as any,
-			...rest,
-		);
-	};
-}
-
-export const union = setOperator('union', false);
-
-export const unionAll = setOperator('union', true);
-
-export const intersect = setOperator('intersect', false);
-
-export const intersectAll = setOperator('intersect', true);
-
-export const except = setOperator('except', false);
-
-export const exceptAll = setOperator('except', true);

From c7846b97f71a40dd528d1068ba1cd1068e8c15de Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Fri, 20 Oct 2023 19:12:42 -0400
Subject: [PATCH 61/72] [SQLite] Simplification by removing intermediary clases
 and making the queries mutable

---
 drizzle-orm/src/mysql-core/dialect.ts         |   2 +-
 drizzle-orm/src/sqlite-core/dialect.ts        |  66 ++-
 .../src/sqlite-core/query-builders/index.ts   |   1 -
 .../src/sqlite-core/query-builders/select.ts  | 148 ++++++-
 .../query-builders/select.types.ts            | 314 +++++++--------
 .../query-builders/set-operators.ts           | 376 ------------------
 6 files changed, 316 insertions(+), 591 deletions(-)
 delete mode 100644 drizzle-orm/src/sqlite-core/query-builders/set-operators.ts

diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index 057565e0f..26521bdaf 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -353,7 +353,7 @@ export class MySqlDialect {
 			return this.buildSetOperationQuery({ leftSelect, setOperator });
 		}
 
-    // Some recursive magic here
+		// Some recursive magic here
 		return this.buildSetOperations(
 			this.buildSetOperationQuery({ leftSelect, setOperator }),
 			rest,
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index 1a65cbc90..f4251309a 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -18,12 +18,7 @@ import {
 } from '~/relations.ts';
 import { and, eq, type Name, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
 import { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
-import type {
-	SQLiteDeleteConfig,
-	SQLiteInsertConfig,
-	SQLiteSetOperationConfig,
-	SQLiteUpdateConfig,
-} from '~/sqlite-core/query-builders/index.ts';
+import type { SQLiteDeleteConfig, SQLiteInsertConfig, SQLiteUpdateConfig } from '~/sqlite-core/query-builders/index.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
@@ -156,8 +151,21 @@ export abstract class SQLiteDialect {
 	}
 
 	buildSelectQuery(
-		{ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, distinct }:
-			SQLiteSelectConfig,
+		{
+			withList,
+			fields,
+			fieldsFlat,
+			where,
+			having,
+			table,
+			joins,
+			orderBy,
+			groupBy,
+			limit,
+			offset,
+			distinct,
+			setOperators,
+		}: SQLiteSelectConfig,
 	): SQL {
 		const fieldsList = fieldsFlat ?? orderSelectedFields<SQLiteColumn>(fields);
 		for (const f of fieldsList) {
@@ -278,18 +286,39 @@ export abstract class SQLiteDialect {
 
 		const offsetSql = offset ? sql` offset ${offset}` : undefined;
 
-		return sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;
+		const finalQuery =
+			sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;
+
+		if (setOperators.length > 0) {
+			return this.buildSetOperations(finalQuery, setOperators);
+		}
+
+		return finalQuery;
+	}
+
+	buildSetOperations(leftSelect: SQL, setOperators: SQLiteSelectConfig['setOperators']): SQL {
+		const [setOperator, ...rest] = setOperators;
+
+		if (!setOperator) {
+			throw new Error('Cannot pass undefined values to any set operator');
+		}
+
+		if (rest.length === 0) {
+			return this.buildSetOperationQuery({ leftSelect, setOperator });
+		}
+
+		// Some recursive magic here
+		return this.buildSetOperations(
+			this.buildSetOperationQuery({ leftSelect, setOperator }),
+			rest,
+		);
 	}
 
 	buildSetOperationQuery({
-		operator,
-		isAll,
 		leftSelect,
-		rightSelect,
-		limit,
-		orderBy,
-		offset,
-	}: SQLiteSetOperationConfig): SQL {
+		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
+	}: { leftSelect: SQL; setOperator: SQLiteSelectConfig['setOperators'][number] }): SQL {
+		// SQLite doesn't support parenthesis in set operations
 		const leftChunk = sql`${leftSelect.getSQL()} `;
 		const rightChunk = sql`${rightSelect.getSQL()}`;
 
@@ -322,7 +351,7 @@ export abstract class SQLiteDialect {
 
 		const limitSql = limit ? sql` limit ${limit}` : undefined;
 
-		const operatorChunk = sql.raw(`${operator} ${isAll ? 'all ' : ''}`);
+		const operatorChunk = sql.raw(`${type} ${isAll ? 'all ' : ''}`);
 
 		const offsetSql = offset ? sql` offset ${offset}` : undefined;
 
@@ -623,6 +652,7 @@ export abstract class SQLiteDialect {
 					limit,
 					offset,
 					orderBy,
+					setOperators: [],
 				});
 
 				where = undefined;
@@ -645,6 +675,7 @@ export abstract class SQLiteDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		} else {
 			result = this.buildSelectQuery({
@@ -659,6 +690,7 @@ export abstract class SQLiteDialect {
 				limit,
 				offset,
 				orderBy,
+				setOperators: [],
 			});
 		}
 
diff --git a/drizzle-orm/src/sqlite-core/query-builders/index.ts b/drizzle-orm/src/sqlite-core/query-builders/index.ts
index 58d909c22..16f0e1d4d 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/index.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/index.ts
@@ -3,5 +3,4 @@ export * from './insert.ts';
 export * from './query-builder.ts';
 export * from './select.ts';
 export * from './select.types.ts';
-export * from './set-operators.ts';
 export * from './update.ts';
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.ts b/drizzle-orm/src/sqlite-core/query-builders/select.ts
index e8443744d..54a1feb5a 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.ts
@@ -1,4 +1,5 @@
 import { entityKind, is } from '~/entity.ts';
+import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
 	GetSelectTableName,
@@ -7,6 +8,7 @@ import type {
 	JoinType,
 	SelectMode,
 	SelectResult,
+	SetOperator,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { RunnableQuery } from '~/runnable-query.ts';
@@ -18,13 +20,24 @@ import type { SubqueryWithSelection } from '~/sqlite-core/subquery.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
 import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
-import { applyMixins, getTableColumns, getTableLikeName, orderSelectedFields, type ValueOrArray } from '~/utils.ts';
+import {
+	applyMixins,
+	getTableColumns,
+	getTableLikeName,
+	haveSameKeys,
+	orderSelectedFields,
+	type ValueOrArray,
+} from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
 import { type ColumnsSelection, View } from '~/view.ts';
 import { SQLiteViewBase } from '../view.ts';
 import type {
+	AnySQLiteSelect,
 	CreateSQLiteSelectFromBuilderMode,
+	GetSQLiteSetOperators,
 	SelectedFields,
+	SetOperatorRightSelect,
+	SQLiteCreateSetOperatorFn,
 	SQLiteJoinFn,
 	SQLiteSelectConfig,
 	SQLiteSelectDynamic,
@@ -33,8 +46,9 @@ import type {
 	SQLiteSelectHKTBase,
 	SQLiteSelectPrepare,
 	SQLiteSelectWithout,
+	SQLiteSetOperatorExcludedMethods,
+	SQLiteSetOperatorWithResult,
 } from './select.types.ts';
-import { SQLiteSetOperatorBuilder } from './set-operators.ts';
 
 export class SQLiteSelectBuilder<
 	TSelection extends SelectedFields | undefined,
@@ -121,19 +135,7 @@ export abstract class SQLiteSelectQueryBuilderBase<
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends SQLiteSetOperatorBuilder<
-	THKT,
-	TTableName,
-	TResultType,
-	TRunResult,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> {
+> extends TypedQueryBuilder<TSelectedFields, TResult> {
 	static readonly [entityKind]: string = 'SQLiteSelectQueryBuilder';
 
 	override readonly _: {
@@ -176,6 +178,7 @@ export abstract class SQLiteSelectQueryBuilderBase<
 			table,
 			fields: { ...fields },
 			distinct,
+			setOperators: [],
 		};
 		this.isPartialSelect = isPartialSelect;
 		this.session = session;
@@ -271,6 +274,57 @@ export abstract class SQLiteSelectQueryBuilderBase<
 
 	fullJoin = this.createJoin('full');
 
+	private createSetOperator(
+		type: SetOperator,
+		isAll: boolean,
+	): <TValue extends SQLiteSetOperatorWithResult<TResult>>(
+		rightSelection:
+			| ((setOperators: GetSQLiteSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| SetOperatorRightSelect<TValue, TResult>,
+	) => SQLiteSelectWithout<
+		this,
+		TDynamic,
+		SQLiteSetOperatorExcludedMethods,
+		true
+	> {
+		return (rightSelection) => {
+			const rightSelect = (typeof rightSelection === 'function'
+				? rightSelection(getSQLiteSetOperators())
+				: rightSelection) as TypedQueryBuilder<
+					any,
+					TResult
+				>;
+
+			if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+
+			this.config.setOperators.push({ type, isAll, rightSelect });
+			return this as any;
+		};
+	}
+
+	union = this.createSetOperator('union', false);
+
+	unionAll = this.createSetOperator('union', true);
+
+	intersect = this.createSetOperator('intersect', false);
+
+	except = this.createSetOperator('except', false);
+
+	/** @internal */
+	addSetOperators(setOperators: SQLiteSelectConfig['setOperators']): SQLiteSelectWithout<
+		this,
+		TDynamic,
+		SQLiteSetOperatorExcludedMethods,
+		true
+	> {
+		this.config.setOperators.push(...setOperators);
+		return this as any;
+	}
+
 	where(
 		where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
 	): SQLiteSelectWithout<this, TDynamic, 'where'> {
@@ -340,20 +394,41 @@ export abstract class SQLiteSelectQueryBuilderBase<
 					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
 				) as TSelection,
 			);
-			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
 		} else {
-			this.config.orderBy = columns as (SQLiteColumn | SQL | SQL.Aliased)[];
+			const orderByArray = columns as (SQLiteColumn | SQL | SQL.Aliased)[];
+
+			if (this.config.setOperators.length > 0) {
+				this.config.setOperators.at(-1)!.orderBy = orderByArray;
+			} else {
+				this.config.orderBy = orderByArray;
+			}
 		}
 		return this as any;
 	}
 
 	limit(limit: number | Placeholder): SQLiteSelectWithout<this, TDynamic, 'limit'> {
-		this.config.limit = limit;
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.limit = limit;
+		} else {
+			this.config.limit = limit;
+		}
 		return this as any;
 	}
 
 	offset(offset: number | Placeholder): SQLiteSelectWithout<this, TDynamic, 'offset'> {
-		this.config.offset = offset;
+		if (this.config.setOperators.length > 0) {
+			this.config.setOperators.at(-1)!.offset = offset;
+		} else {
+			this.config.offset = offset;
+		}
 		return this as any;
 	}
 
@@ -482,3 +557,38 @@ export class SQLiteSelectBase<
 }
 
 applyMixins(SQLiteSelectBase, [QueryPromise]);
+
+function createSetOperator(type: SetOperator, isAll: boolean): SQLiteCreateSetOperatorFn {
+	return (leftSelect, rightSelect, ...restSelects) => {
+		const setOperators = [rightSelect, ...restSelects].map((select) => ({
+			type,
+			isAll,
+			rightSelect: select as AnySQLiteSelect,
+		}));
+
+		for (const setOperator of setOperators) {
+			if (!haveSameKeys((leftSelect as any).getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
+				throw new Error(
+					'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
+				);
+			}
+		}
+
+		return (leftSelect as AnySQLiteSelect).addSetOperators(setOperators) as any;
+	};
+}
+
+const getSQLiteSetOperators = () => ({
+	union,
+	unionAll,
+	intersect,
+	except,
+});
+
+export const union = createSetOperator('union', false);
+
+export const unionAll = createSetOperator('union', true);
+
+export const intersect = createSetOperator('intersect', false);
+
+export const except = createSetOperator('except', false);
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 90cfdef58..32b47486a 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -28,7 +28,6 @@ import type { ColumnsSelection, View } from '~/view.ts';
 import type { SQLitePreparedQuery } from '../session.ts';
 import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.ts';
 import type { SQLiteSelectBase, SQLiteSelectQueryBuilderBase } from './select.ts';
-import type { SQLiteSetOperatorBase, SQLiteSetOperatorBuilder } from './set-operators.ts';
 
 export interface SQLiteSelectJoinConfig {
 	on: SQL | undefined;
@@ -64,6 +63,14 @@ export interface SQLiteSelectConfig {
 	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
 	groupBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
 	distinct?: boolean;
+	setOperators: {
+		rightSelect: TypedQueryBuilder<any, any>;
+		type: SetOperator;
+		isAll: boolean;
+		orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
+		limit?: number | Placeholder;
+		offset?: number | Placeholder;
+	}[];
 }
 
 export type SQLiteJoin<
@@ -185,6 +192,27 @@ export interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
 	>;
 }
 
+export type SQLiteSetOperatorExcludedMethods = Exclude<
+	keyof AnySQLiteSelectQueryBuilder,
+	// Only add the methods that a SetOperator is supposed to have
+	| 'orderBy'
+	| 'limit'
+	| 'offset'
+	| 'union'
+	| 'unionAll'
+	| 'intersect'
+	| 'intersectAll'
+	| 'except'
+	| 'exceptAll'
+	| '_'
+	| 'getSQL'
+	| 'as'
+	| 'addSetOperators'
+	| 'toSQL'
+	| '$dynamic'
+	| 'getSelectedFields'
+>;
+
 export type CreateSQLiteSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
 	TTableName extends string | undefined,
@@ -212,22 +240,23 @@ export type SQLiteSelectWithout<
 	T extends AnySQLiteSelectQueryBuilder,
 	TDynamic extends boolean,
 	K extends keyof T & string,
-> = TDynamic extends true ? T
-	: Omit<
-		SQLiteSelectBase<
-			T['_']['tableName'],
-			T['_']['resultType'],
-			T['_']['runResult'],
-			T['_']['selection'],
-			T['_']['selectMode'],
-			T['_']['nullabilityMap'],
-			TDynamic,
-			T['_']['excludedMethods'] | K,
-			T['_']['result'],
-			T['_']['selectedFields']
-		>,
-		T['_']['excludedMethods'] | K
-	>;
+	TResetExcluded extends boolean = false,
+> = TDynamic extends true ? T : Omit<
+	SQLiteSelectKind<
+		T['_']['hkt'],
+		T['_']['tableName'],
+		T['_']['resultType'],
+		T['_']['runResult'],
+		T['_']['selection'],
+		T['_']['selectMode'],
+		T['_']['nullabilityMap'],
+		TDynamic,
+		TResetExcluded extends true ? K : T['_']['excludedMethods'] | K,
+		T['_']['result'],
+		T['_']['selectedFields']
+	>,
+	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
+>;
 
 export type SQLiteSelectExecute<T extends AnySQLiteSelect> = T['_']['result'];
 
@@ -261,11 +290,11 @@ export type SQLiteSelectQueryBuilder<
 	TTableName extends string | undefined = string | undefined,
 	TResultType extends 'sync' | 'async' = 'sync' | 'async',
 	TRunResult = unknown,
-	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelection extends ColumnsSelection = ColumnsSelection,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 	TResult extends any[] = unknown[],
-	TSelectedFields extends ColumnsSelection = Record<string, any>,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
 > = SQLiteSelectQueryBuilderBase<
 	THKT,
 	TTableName,
@@ -294,76 +323,14 @@ export type AnySQLiteSelectQueryBuilder = SQLiteSelectQueryBuilderBase<
 	any
 >;
 
-export type SQLiteSetOperatorBaseWithResult<T extends any[]> = SQLiteSetOperatorInterface<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	T,
-	any
->;
-
-export type SQLiteSelect<
-	TTableName extends string | undefined = string | undefined,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
-	TRunResult = unknown,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = SQLiteSelectBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
-
-export type AnySQLiteSelect = SQLiteSelectBase<any, any, any, any, any, any, any, any, any, any>;
-
-export type SetOperatorRightSelect<
-	TValue extends SQLiteSetOperatorBaseWithResult<TResult>,
-	TResult extends any[],
-> = TValue extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, infer TValueResult, any>
-	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
-			TValueObj,
-			TResult[number],
-			TypedQueryBuilder<any, TValueResult>
-		>
-	: never
-	: TValue;
-
-export type SetOperatorRestSelect<
-	TValue extends readonly SQLiteSetOperatorBaseWithResult<TResult>[],
-	TResult extends any[],
-> = TValue extends [infer First, ...infer Rest]
-	? First extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, infer TValueResult, any>
-		? TValueResult extends Array<infer TValueObj>
-			? Rest extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any, any, any>[] ? [
-					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
-					...SetOperatorRestSelect<Rest, TResult>,
-				]
-			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
-		: never
-	: never
-	: TValue;
-
-export interface SQLiteSetOperationConfig {
-	fields: Record<string, unknown>;
-	operator: SetOperator;
-	isAll: boolean;
-	leftSelect: AnySQLiteSetOperatorBase;
-	rightSelect: TypedQueryBuilder<any, any[]>;
-	limit?: number | Placeholder;
-	orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
-	offset?: number | Placeholder;
-}
+export type AnySQLiteSetOperatorInterface = SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, any>;
 
 export interface SQLiteSetOperatorInterface<
-	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
+	TSelectMode extends SelectMode = 'single',
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
 	TDynamic extends boolean = false,
@@ -371,9 +338,8 @@ export interface SQLiteSetOperatorInterface<
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	Omit<
-		SQLiteSetOperatorBuilder<
-			THKT,
+	Pick<
+		SQLiteSelectBase<
 			TTableName,
 			TResultType,
 			TRunResult,
@@ -385,12 +351,11 @@ export interface SQLiteSetOperatorInterface<
 			TResult,
 			TSelectedFields
 		>,
-		'joinsNotNullableMap' | 'session' | 'dialect' | 'createSetOperator'
+		never
 	>
 {
 	_: {
-		dialect: 'sqlite';
-		readonly hkt: THKT;
+		readonly hkt: SQLiteSelectHKTBase;
 		readonly tableName: TTableName;
 		readonly resultType: TResultType;
 		readonly runResult: TRunResult;
@@ -404,9 +369,7 @@ export interface SQLiteSetOperatorInterface<
 	};
 }
 
-export type AnySQLiteSetOperatorBase = SQLiteSetOperatorInterface<
-	any,
-	any,
+export type SQLiteSetOperatorWithResult<TResult extends any[]> = SQLiteSetOperatorInterface<
 	any,
 	any,
 	any,
@@ -415,26 +378,81 @@ export type AnySQLiteSetOperatorBase = SQLiteSetOperatorInterface<
 	any,
 	any,
 	any,
+	TResult,
 	any
 >;
 
+export type SQLiteSelect<
+	TTableName extends string | undefined = string | undefined,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = SQLiteSelectBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
+
+export type AnySQLiteSelect = SQLiteSelectBase<any, any, any, any, any, any, any, any, any, any>;
+
+export type SQLiteSetOperator<
+	TTableName extends string | undefined = string | undefined,
+	TResultType extends 'sync' | 'async' = 'sync' | 'async',
+	TRunResult = unknown,
+	TSelection extends ColumnsSelection = Record<string, any>,
+	TSelectMode extends SelectMode = SelectMode,
+	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
+> = SQLiteSelectBase<
+	TTableName,
+	TResultType,
+	TRunResult,
+	TSelection,
+	TSelectMode,
+	TNullabilityMap,
+	true,
+	SQLiteSetOperatorExcludedMethods
+>;
+
+export type SetOperatorRightSelect<
+	TValue extends SQLiteSetOperatorWithResult<TResult>,
+	TResult extends any[],
+> = TValue extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
+	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
+			TValueObj,
+			TResult[number],
+			TypedQueryBuilder<any, TValueResult>
+		>
+	: never
+	: TValue;
+
+export type SetOperatorRestSelect<
+	TValue extends readonly SQLiteSetOperatorWithResult<TResult>[],
+	TResult extends any[],
+> = TValue extends [infer First, ...infer Rest]
+	? First extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
+		? TValueResult extends Array<infer TValueObj> ? Rest extends AnySQLiteSetOperatorInterface[] ? [
+					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
+					...SetOperatorRestSelect<Rest, TResult>,
+				]
+			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
+		: never
+	: never
+	: TValue;
+
 export type SQLiteCreateSetOperatorFn = <
-	THKT extends SQLiteSelectHKTBase,
 	TTableName extends string | undefined,
 	TResultType extends 'sync' | 'async',
 	TRunResult,
 	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability>,
-	TValue extends SQLiteSetOperatorBaseWithResult<TResult>,
-	TRest extends SQLiteSetOperatorBaseWithResult<TResult>[],
+	TValue extends SQLiteSetOperatorWithResult<TResult>,
+	TRest extends SQLiteSetOperatorWithResult<TResult>[],
+	TSelectMode extends SelectMode = 'single',
+	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
+		: {},
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 >(
 	leftSelect: SQLiteSetOperatorInterface<
-		THKT,
 		TTableName,
 		TResultType,
 		TRunResult,
@@ -448,85 +466,27 @@ export type SQLiteCreateSetOperatorFn = <
 	>,
 	rightSelect: SetOperatorRightSelect<TValue, TResult>,
 	...restSelects: SetOperatorRestSelect<TRest, TResult>
-) => SQLiteSetOperatorBase<
-	TTableName,
-	TResultType,
-	TRunResult,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
+) => SQLiteSelectWithout<
+	SQLiteSelectBase<
+		TTableName,
+		TResultType,
+		TRunResult,
+		TSelection,
+		TSelectMode,
+		TNullabilityMap,
+		TDynamic,
+		TExcludedMethods,
+		TResult,
+		TSelectedFields
+	>,
 	false,
-	never,
-	TResult,
-	TSelectedFields
->;
-
-export type AnySQLiteSetOperator = SQLiteSetOperatorBase<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any
->;
-
-export type SQLiteSetOperator<
-	TTableName extends string | undefined = string | undefined,
-	TResultType extends 'sync' | 'async' = 'sync' | 'async',
-	TRunResult = unknown,
-	TSelection extends ColumnsSelection = Record<string, any>,
-	TSelectMode extends SelectMode = SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = SQLiteSetOperatorBase<TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, true, never>;
-
-export type AnySQLiteSetOperatorBuilder = SQLiteSetOperatorBuilder<
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any,
-	any
+	SQLiteSetOperatorExcludedMethods,
+	true
 >;
 
-export type SQLiteSetOperatorWithout<
-	T extends AnySQLiteSetOperator,
-	TDynamic extends boolean,
-	K extends keyof T & string,
-> = TDynamic extends true ? T
-	: Omit<
-		SQLiteSetOperatorBase<
-			T['_']['tableName'],
-			T['_']['resultType'],
-			T['_']['runResult'],
-			T['_']['selection'],
-			T['_']['selectMode'],
-			T['_']['nullabilityMap'],
-			TDynamic,
-			T['_']['excludedMethods'] | K,
-			T['_']['result'],
-			T['_']['selectedFields']
-		>,
-		T['_']['excludedMethods'] | K
-	>;
-
-export type SQLiteSetOperatorDynamic<T extends AnySQLiteSetOperatorBuilder> = SQLiteSetOperatorBase<
-	T['_']['tableName'],
-	T['_']['resultType'],
-	T['_']['runResult'],
-	T['_']['selection'],
-	T['_']['selectMode'],
-	T['_']['nullabilityMap'],
-	true,
-	never,
-	T['_']['result'],
-	T['_']['selectedFields']
->;
+export type GetSQLiteSetOperators = {
+	union: SQLiteCreateSetOperatorFn;
+	intersect: SQLiteCreateSetOperatorFn;
+	except: SQLiteCreateSetOperatorFn;
+	unionAll: SQLiteCreateSetOperatorFn;
+};
diff --git a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts b/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
deleted file mode 100644
index 1538a1b0b..000000000
--- a/drizzle-orm/src/sqlite-core/query-builders/set-operators.ts
+++ /dev/null
@@ -1,376 +0,0 @@
-import { entityKind } from '~/entity.ts';
-import {
-	orderSelectedFields,
-	type Placeholder,
-	type Query,
-	SelectionProxyHandler,
-	type SQL,
-	Subquery,
-	type ValueOrArray,
-} from '~/index.ts';
-import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type {
-	BuildSubquerySelection,
-	JoinNullability,
-	SelectMode,
-	SelectResult,
-	SetOperator,
-} from '~/query-builders/select.types.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
-import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
-import { applyMixins, haveSameKeys, type PromiseOf } from '~/utils.ts';
-import type { ColumnsSelection } from '~/view.ts';
-import type { SQLiteColumn } from '../columns/common.ts';
-import type { SQLiteDialect } from '../dialect.ts';
-import type { SubqueryWithSelection } from '../subquery.ts';
-import type {
-	SetOperatorRightSelect,
-	SQLiteCreateSetOperatorFn,
-	SQLiteSelectHKTBase,
-	SQLiteSetOperationConfig,
-	SQLiteSetOperatorBaseWithResult,
-	SQLiteSetOperatorDynamic,
-	SQLiteSetOperatorInterface,
-	SQLiteSetOperatorWithout,
-} from './select.types.ts';
-
-const getSQLiteSetOperators = () => {
-	return {
-		union,
-		unionAll,
-		intersect,
-		except,
-	};
-};
-
-type SQLiteSetOperators = ReturnType<typeof getSQLiteSetOperators>;
-
-export abstract class SQLiteSetOperatorBuilder<
-	THKT extends SQLiteSelectHKTBase,
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<
-	TSelectedFields,
-	TResult
-> {
-	static readonly [entityKind]: string = 'SQLiteSetOperatorBuilder';
-
-	abstract override readonly _: {
-		dialect: 'sqlite';
-		readonly hkt: THKT;
-		readonly tableName: TTableName;
-		readonly resultType: TResultType;
-		readonly runResult: TRunResult;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-	};
-
-	protected abstract joinsNotNullableMap: Record<string, boolean>;
-	protected abstract config: {
-		fields: Record<string, unknown>;
-		limit?: number | Placeholder;
-		orderBy?: (SQLiteColumn | SQL | SQL.Aliased)[];
-		offset?: number | Placeholder;
-	};
-	/* @internal */
-	protected abstract readonly session: SQLiteSession<any, any, any, any> | undefined;
-	protected abstract dialect: SQLiteDialect;
-
-	/** @internal */
-	getSetOperatorConfig() {
-		return {
-			session: this.session,
-			dialect: this.dialect,
-			joinsNotNullableMap: this.joinsNotNullableMap,
-			fields: this.config.fields,
-		};
-	}
-
-	private createSetOperator(
-		type: SetOperator,
-		isAll: boolean,
-	): <TValue extends SQLiteSetOperatorBaseWithResult<TResult>>(
-		rightSelect:
-			| ((setOperator: SQLiteSetOperators) => SetOperatorRightSelect<TValue, TResult>)
-			| SetOperatorRightSelect<TValue, TResult>,
-	) => SQLiteSetOperatorBase<
-		TTableName,
-		TResultType,
-		TRunResult,
-		TSelection,
-		TSelectMode,
-		TNullabilityMap,
-		false,
-		never,
-		TResult,
-		TSelectedFields
-	> {
-		return (rightSelect) => {
-			const rightSelectOrig = typeof rightSelect === 'function' ? rightSelect(getSQLiteSetOperators()) : rightSelect;
-
-			return new SQLiteSetOperatorBase(type, isAll, this, rightSelectOrig as any) as any;
-		};
-	}
-
-	union = this.createSetOperator('union', false);
-
-	unionAll = this.createSetOperator('union', true);
-
-	intersect = this.createSetOperator('intersect', false);
-
-	except = this.createSetOperator('except', false);
-}
-
-export interface SQLiteSetOperatorBase<
-	TTableName extends string | undefined,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TResultType extends 'sync' | 'async',
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TDynamic extends boolean = false,
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends TypedQueryBuilder<TSelectedFields, TResult>, QueryPromise<TResult>, RunnableQuery<TResult, 'sqlite'> {}
-
-export class SQLiteSetOperatorBase<
-	TTableName extends string | undefined,
-	TResultType extends 'sync' | 'async',
-	TRunResult,
-	TSelection extends ColumnsSelection,
-	TSelectMode extends SelectMode,
-	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
-		: {},
-	TDynamic extends boolean = false,
-	TExcludedMethods extends string = never,
-	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
-	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends SQLiteSetOperatorBuilder<
-	SQLiteSelectHKTBase,
-	TTableName,
-	TResultType,
-	TRunResult,
-	TSelection,
-	TSelectMode,
-	TNullabilityMap,
-	TDynamic,
-	TExcludedMethods,
-	TResult,
-	TSelectedFields
-> {
-	static readonly [entityKind]: string = 'SQLiteSetOperator';
-
-	override readonly _: {
-		dialect: 'sqlite';
-		readonly hkt: SQLiteSelectHKTBase;
-		readonly tableName: TTableName;
-		readonly resultType: TResultType;
-		readonly runResult: TRunResult;
-		readonly selection: TSelection;
-		readonly selectMode: TSelectMode;
-		readonly nullabilityMap: TNullabilityMap;
-		readonly dynamic: TDynamic;
-		readonly excludedMethods: TExcludedMethods;
-		readonly result: TResult;
-		readonly selectedFields: TSelectedFields;
-	};
-
-	protected joinsNotNullableMap: Record<string, boolean>;
-	protected config: SQLiteSetOperationConfig;
-	/* @internal */
-	readonly session: SQLiteSession<any, any, any, any> | undefined;
-	protected dialect: SQLiteDialect;
-
-	constructor(
-		operator: SetOperator,
-		isAll: boolean,
-		leftSelect: SQLiteSetOperatorInterface<
-			SQLiteSelectHKTBase,
-			TTableName,
-			TResultType,
-			TRunResult,
-			TSelection,
-			TSelectMode,
-			TNullabilityMap,
-			TDynamic,
-			TExcludedMethods,
-			TResult,
-			TSelectedFields
-		>,
-		rightSelect: TypedQueryBuilder<any, TResult>,
-	) {
-		super();
-
-		const leftSelectedFields = leftSelect.getSelectedFields();
-		const rightSelectedFields = rightSelect.getSelectedFields();
-
-		if (!haveSameKeys(leftSelectedFields, rightSelectedFields)) {
-			throw new Error(
-				'Set operator error (union / intersect / except): selected fields are not the same or are in a different order',
-			);
-		}
-
-		const { session, dialect, joinsNotNullableMap, fields } = leftSelect.getSetOperatorConfig();
-
-		this._ = {
-			selectedFields: fields as TSelectedFields,
-		} as this['_'];
-
-		this.session = session;
-		this.dialect = dialect;
-		this.joinsNotNullableMap = joinsNotNullableMap;
-		this.config = {
-			fields,
-			operator,
-			isAll,
-			leftSelect,
-			rightSelect,
-		} as SQLiteSetOperationConfig;
-	}
-
-	orderBy(
-		builder: (aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>,
-	): SQLiteSetOperatorWithout<this, TDynamic, 'orderBy'>;
-	orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): SQLiteSetOperatorWithout<this, TDynamic, 'orderBy'>;
-	orderBy(
-		...columns:
-			| [(aliases: TSelection) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>]
-			| (SQLiteColumn | SQL | SQL.Aliased)[]
-	): SQLiteSetOperatorWithout<this, TDynamic, 'orderBy'> {
-		if (typeof columns[0] === 'function') {
-			const orderBy = columns[0](
-				new Proxy(
-					this.config.fields,
-					new SelectionProxyHandler({ sqlAliasedBehavior: 'alias', sqlBehavior: 'sql' }),
-				) as TSelection,
-			);
-			this.config.orderBy = Array.isArray(orderBy) ? orderBy : [orderBy];
-		} else {
-			this.config.orderBy = columns as (SQLiteColumn | SQL | SQL.Aliased)[];
-		}
-		return this as any;
-	}
-
-	limit(limit: number): SQLiteSetOperatorWithout<this, TDynamic, 'limit'> {
-		this.config.limit = limit;
-		return this as any;
-	}
-
-	offset(offset: number | Placeholder): SQLiteSetOperatorWithout<this, TDynamic, 'offset'> {
-		this.config.offset = offset;
-		return this as any;
-	}
-
-	toSQL(): Query {
-		const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-		return rest;
-	}
-
-	override getSQL(): SQL<unknown> {
-		return this.dialect.buildSetOperationQuery(this.config);
-	}
-
-	prepare(isOneTimeQuery?: boolean): SQLitePreparedQuery<
-		{
-			type: TResultType;
-			run: TRunResult;
-			all: TResult;
-			get: SelectResult<TSelection, TSelectMode, TNullabilityMap> | undefined;
-			values: any[][];
-			execute: TResult;
-		}
-	> {
-		if (!this.session) {
-			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
-		}
-		const fieldsList = orderSelectedFields<SQLiteColumn>(this.config.fields);
-		const query = this.session[isOneTimeQuery ? 'prepareOneTimeQuery' : 'prepareQuery'](
-			this.dialect.sqlToQuery(this.getSQL()),
-			fieldsList,
-			'all',
-		);
-		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query as ReturnType<this['prepare']>;
-	}
-
-	run: ReturnType<this['prepare']>['run'] = (placeholderValues) => {
-		return this.prepare(true).run(placeholderValues);
-	};
-
-	all: ReturnType<this['prepare']>['all'] = (placeholderValues) => {
-		return this.prepare(true).all(placeholderValues);
-	};
-
-	get: ReturnType<this['prepare']>['get'] = (placeholderValues) => {
-		return this.prepare(true).get(placeholderValues);
-	};
-
-	values: ReturnType<this['prepare']>['values'] = (placeholderValues) => {
-		return this.prepare(true).values(placeholderValues);
-	};
-
-	async execute(): Promise<TResult> {
-		return this.all() as PromiseOf<ReturnType<this['execute']>>;
-	}
-
-	as<TAlias extends string>(
-		alias: TAlias,
-	): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias> {
-		return new Proxy(
-			new Subquery(this.getSQL(), this.config.fields, alias),
-			new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }),
-		) as SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
-	}
-
-	$dynamic(): SQLiteSetOperatorDynamic<this> {
-		return this as any;
-	}
-}
-
-applyMixins(SQLiteSetOperatorBase, [QueryPromise]);
-
-function createSetOperator(type: SetOperator, isAll: boolean): SQLiteCreateSetOperatorFn {
-	return (leftSelect, rightSelect, ...restSelects) => {
-		if (restSelects.length === 0) {
-			return new SQLiteSetOperatorBase(type, isAll, leftSelect, rightSelect as any) as any;
-		}
-
-		const [select, ...rest] = restSelects;
-		if (!select) throw new Error('Cannot pass undefined values to any set operator');
-
-		return createSetOperator(type, isAll)(
-			new SQLiteSetOperatorBase(type, isAll, leftSelect, rightSelect as any),
-			select as any,
-			...rest,
-		);
-	};
-}
-
-export const union = createSetOperator('union', false);
-
-export const unionAll = createSetOperator('union', true);
-
-export const intersect = createSetOperator('intersect', false);
-
-export const except = createSetOperator('except', false);

From 1128c12f4536e3d682012f51bc530695c4293fb0 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Mon, 30 Oct 2023 23:15:41 -0400
Subject: [PATCH 62/72] [MySql] Types simplification from review and fixed
 tests for western hemisphere

---
 .../mysql-core/query-builders/select.types.ts | 71 ++++++-------------
 integration-tests/tests/mysql-proxy.test.ts   |  4 +-
 integration-tests/tests/mysql-schema.test.ts  |  6 +-
 integration-tests/tests/mysql.custom.test.ts  |  6 +-
 .../tests/mysql.prefixed.test.ts              |  4 +-
 integration-tests/tests/mysql.test.ts         |  6 +-
 integration-tests/tests/utils.ts              |  6 ++
 7 files changed, 43 insertions(+), 60 deletions(-)

diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index 1acb4a5e5..022219522 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -202,26 +202,16 @@ export interface MySqlSelectHKT extends MySqlSelectHKTBase {
 	>;
 }
 
-export type MySqlSetOperatorExcludedMethods = Exclude<
-	keyof AnyMySqlSelectQueryBuilder,
-	// Only add the methods that a SetOperator is supposed to have
-	| 'orderBy'
-	| 'limit'
-	| 'offset'
-	| 'union'
-	| 'unionAll'
-	| 'intersect'
-	| 'intersectAll'
-	| 'except'
-	| 'exceptAll'
-	| '_'
-	| 'getSQL'
-	| 'as'
-	| 'addSetOperators'
-	| 'toSQL'
-	| '$dynamic'
-	| 'getSelectedFields'
->;
+export type MySqlSetOperatorExcludedMethods =
+	| 'where'
+	| 'having'
+	| 'groupBy'
+	| 'session'
+	| 'leftJoin'
+	| 'rightJoin'
+	| 'innerJoin'
+	| 'fullJoin'
+	| 'for';
 
 export type MySqlSelectWithout<
 	T extends AnyMySqlSelectQueryBuilder,
@@ -230,7 +220,7 @@ export type MySqlSelectWithout<
 	TResetExcluded extends boolean = false,
 > = TDynamic extends true ? T : Omit<
 	MySqlSelectKind<
-    T['_']['hkt'],
+		T['_']['hkt'],
 		T['_']['tableName'],
 		T['_']['selection'],
 		T['_']['selectMode'],
@@ -312,22 +302,7 @@ export interface MySqlSetOperatorInterface<
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	Pick<
-		MySqlSelectBase<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TPreparedQueryHKT,
-			TNullabilityMap,
-			TDynamic,
-			TExcludedMethods,
-			TResult,
-			TSelectedFields
-		>,
-		never
-	>
-{
+> {
 	_: {
 		readonly hkt: MySqlSelectHKT;
 		readonly tableName: TTableName;
@@ -383,12 +358,11 @@ export type SetOperatorRightSelect<
 	TValue extends MySqlSetOperatorWithResult<TResult>,
 	TResult extends any[],
 > = TValue extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
-	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
-			TValueObj,
-			TResult[number],
-			TypedQueryBuilder<any, TValueResult>
-		>
-	: never
+	? ValidateShape<
+		TValueResult[number],
+		TResult[number],
+		TypedQueryBuilder<any, TValueResult>
+	>
 	: TValue;
 
 export type SetOperatorRestSelect<
@@ -396,12 +370,11 @@ export type SetOperatorRestSelect<
 	TResult extends any[],
 > = TValue extends [infer First, ...infer Rest]
 	? First extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
-		? TValueResult extends Array<infer TValueObj> ? Rest extends AnyMySqlSetOperatorInterface[] ? [
-					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
-					...SetOperatorRestSelect<Rest, TResult>,
-				]
-			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
-		: never
+		? Rest extends AnyMySqlSetOperatorInterface[] ? [
+				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
+				...SetOperatorRestSelect<Rest, TResult>,
+			]
+		: ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>[]>
 	: never
 	: TValue;
 
diff --git a/integration-tests/tests/mysql-proxy.test.ts b/integration-tests/tests/mysql-proxy.test.ts
index c18f4fb84..861d6811e 100644
--- a/integration-tests/tests/mysql-proxy.test.ts
+++ b/integration-tests/tests/mysql-proxy.test.ts
@@ -32,7 +32,7 @@ import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
 import getPort from 'get-port';
 import * as mysql from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
-import { type Equal, Expect } from './utils.ts';
+import { type Equal, Expect, toLocalDate } from './utils.ts';
 
 const ENABLE_LOGGING = false;
 
@@ -1079,7 +1079,7 @@ test.serial('insert + select all possible dates', async (t) => {
 	t.assert(typeof res[0]?.datetimeAsString === 'string');
 
 	t.deepEqual(res, [{
-		date: new Date('2022-11-11'),
+		date: toLocalDate(new Date('2022-11-11')),
 		dateAsString: '2022-11-11',
 		time: '12:12:12',
 		datetime: new Date('2022-11-11'),
diff --git a/integration-tests/tests/mysql-schema.test.ts b/integration-tests/tests/mysql-schema.test.ts
index 08a62bd16..f82d47533 100644
--- a/integration-tests/tests/mysql-schema.test.ts
+++ b/integration-tests/tests/mysql-schema.test.ts
@@ -27,6 +27,7 @@ import { drizzle } from 'drizzle-orm/mysql2';
 import getPort from 'get-port';
 import * as mysql from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
+import { toLocalDate } from './utils';
 
 const mySchema = mysqlSchema('mySchema');
 
@@ -471,7 +472,8 @@ test.serial('build query insert with onDuplicate', async (t) => {
 		.toSQL();
 
 	t.deepEqual(query, {
-		sql: 'insert into `mySchema`.`userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (default, ?, default, ?, default) on duplicate key update `name` = ?',
+		sql:
+			'insert into `mySchema`.`userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (default, ?, default, ?, default) on duplicate key update `name` = ?',
 		params: ['John', '["foo","bar"]', 'John1'],
 	});
 });
@@ -740,7 +742,7 @@ test.serial('insert + select all possible dates', async (t) => {
 	t.assert(typeof res[0]?.datetimeAsString === 'string');
 
 	t.deepEqual(res, [{
-		date: new Date('2022-11-11'),
+		date: toLocalDate(new Date('2022-11-11')),
 		dateAsString: '2022-11-11',
 		time: '12:12:12',
 		datetime: new Date('2022-11-11'),
diff --git a/integration-tests/tests/mysql.custom.test.ts b/integration-tests/tests/mysql.custom.test.ts
index e0ad8df25..c60b88e47 100644
--- a/integration-tests/tests/mysql.custom.test.ts
+++ b/integration-tests/tests/mysql.custom.test.ts
@@ -25,6 +25,7 @@ import { migrate } from 'drizzle-orm/mysql2/migrator';
 import getPort from 'get-port';
 import * as mysql from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
+import { toLocalDate } from './utils';
 
 const customSerial = customType<{ data: number; notNull: true; default: true }>({
 	dataType() {
@@ -486,7 +487,8 @@ test.serial('build query insert with onDuplicate', async (t) => {
 		.toSQL();
 
 	t.deepEqual(query, {
-		sql: 'insert into `userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (default, ?, default, ?, default) on duplicate key update `name` = ?',
+		sql:
+			'insert into `userstest` (`id`, `name`, `verified`, `jsonb`, `created_at`) values (default, ?, default, ?, default) on duplicate key update `name` = ?',
 		params: ['John', '["foo","bar"]', 'John1'],
 	});
 });
@@ -777,7 +779,7 @@ test.serial('insert + select all possible dates', async (t) => {
 	t.assert(typeof res[0]?.datetimeAsString === 'string');
 
 	t.deepEqual(res, [{
-		date: new Date('2022-11-11'),
+		date: toLocalDate(new Date('2022-11-11')),
 		dateAsString: '2022-11-11',
 		time: '12:12:12',
 		datetime: new Date('2022-11-11'),
diff --git a/integration-tests/tests/mysql.prefixed.test.ts b/integration-tests/tests/mysql.prefixed.test.ts
index c4b4d25f7..324dced00 100644
--- a/integration-tests/tests/mysql.prefixed.test.ts
+++ b/integration-tests/tests/mysql.prefixed.test.ts
@@ -41,7 +41,7 @@ import { migrate } from 'drizzle-orm/mysql2/migrator';
 import getPort from 'get-port';
 import * as mysql from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
-import { type Equal, Expect } from './utils.ts';
+import { type Equal, Expect, toLocalDate } from './utils.ts';
 
 const ENABLE_LOGGING = false;
 
@@ -793,7 +793,7 @@ test.serial('insert + select all possible dates', async (t) => {
 	t.assert(typeof res[0]?.datetimeAsString === 'string');
 
 	t.deepEqual(res, [{
-		date: new Date('2022-11-11'),
+		date: toLocalDate(new Date('2022-11-11')),
 		dateAsString: '2022-11-11',
 		time: '12:12:12',
 		datetime: new Date('2022-11-11'),
diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index 4da40a326..6028a299a 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -42,9 +42,9 @@ import {
 	text,
 	time,
 	timestamp,
+	tinyint,
 	union,
 	unionAll,
-	tinyint,
 	unique,
 	uniqueIndex,
 	uniqueKeyName,
@@ -56,7 +56,7 @@ import { migrate } from 'drizzle-orm/mysql2/migrator';
 import getPort from 'get-port';
 import * as mysql from 'mysql2/promise';
 import { v4 as uuid } from 'uuid';
-import { type Equal, Expect } from './utils.ts';
+import { type Equal, Expect, toLocalDate } from './utils.ts';
 
 const ENABLE_LOGGING = false;
 
@@ -1132,7 +1132,7 @@ test.serial('insert + select all possible dates', async (t) => {
 	t.assert(typeof res[0]?.datetimeAsString === 'string');
 
 	t.deepEqual(res, [{
-		date: new Date('2022-11-11'),
+		date: toLocalDate(new Date('2022-11-11')),
 		dateAsString: '2022-11-11',
 		time: '12:12:12',
 		datetime: new Date('2022-11-11'),
diff --git a/integration-tests/tests/utils.ts b/integration-tests/tests/utils.ts
index 199ed1a57..2d021a2e3 100644
--- a/integration-tests/tests/utils.ts
+++ b/integration-tests/tests/utils.ts
@@ -3,3 +3,9 @@
 export function Expect<T extends true>() {}
 
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+
+export function toLocalDate(date: Date) {
+	const localTime = new Date(date.getTime() - date.getTimezoneOffset() * 60000);
+	localTime.setUTCHours(0);
+	return localTime;
+}

From 99b2a3c5d3684fac73da2c7230f04e15a0601c80 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Mon, 30 Oct 2023 23:22:49 -0400
Subject: [PATCH 63/72] [Pg] Types simplification from review

---
 .../pg-core/query-builders/select.types.ts    | 68 ++++++-------------
 1 file changed, 20 insertions(+), 48 deletions(-)

diff --git a/drizzle-orm/src/pg-core/query-builders/select.types.ts b/drizzle-orm/src/pg-core/query-builders/select.types.ts
index 4d8ba939f..d07784b06 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.types.ts
@@ -211,26 +211,15 @@ export type CreatePgSelectFromBuilderMode<
 > = TBuilderMode extends 'db' ? PgSelectBase<TTableName, TSelection, TSelectMode>
 	: PgSelectQueryBuilderBase<PgSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode>;
 
-export type PgSetOperatorExcludedMethods = Exclude<
-	keyof AnyPgSelectQueryBuilder,
-	// Only add the methods that a SetOperator is supposed to have
-	| 'orderBy'
-	| 'limit'
-	| 'offset'
-	| 'union'
-	| 'unionAll'
-	| 'intersect'
-	| 'intersectAll'
-	| 'except'
-	| 'exceptAll'
-	| '_'
-	| 'getSQL'
-	| 'as'
-	| 'addSetOperators'
-	| 'toSQL'
-	| '$dynamic'
-	| 'getSelectedFields'
->;
+export type PgSetOperatorExcludedMethods =
+	| 'leftJoin'
+	| 'rightJoin'
+	| 'innerJoin'
+	| 'fullJoin'
+	| 'where'
+	| 'having'
+	| 'groupBy'
+	| 'for';
 
 export type PgSelectWithout<
 	T extends AnyPgSelectQueryBuilder,
@@ -304,21 +293,7 @@ export interface PgSetOperatorInterface<
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	Pick<
-		PgSelectBase<
-			TTableName,
-			TSelection,
-			TSelectMode,
-			TNullabilityMap,
-			TDynamic,
-			TExcludedMethods,
-			TResult,
-			TSelectedFields
-		>,
-		never
-	>
-{
+> {
 	_: {
 		readonly hkt: PgSelectHKT;
 		readonly tableName: TTableName;
@@ -369,13 +344,11 @@ export type PgSetOperator<
 export type SetOperatorRightSelect<
 	TValue extends PgSetOperatorWithResult<TResult>,
 	TResult extends any[],
-> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
-	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
-			TValueObj,
-			TResult[number],
-			TypedQueryBuilder<any, TValueResult>
-		>
-	: never
+> = TValue extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any> ? ValidateShape<
+		TValueResult[number],
+		TResult[number],
+		TypedQueryBuilder<any, TValueResult>
+	>
 	: TValue;
 
 export type SetOperatorRestSelect<
@@ -383,12 +356,11 @@ export type SetOperatorRestSelect<
 	TResult extends any[],
 > = TValue extends [infer First, ...infer Rest]
 	? First extends PgSetOperatorInterface<any, any, any, any, any, any, infer TValueResult, any>
-		? TValueResult extends Array<infer TValueObj> ? Rest extends AnyPgSetOperatorInterface[] ? [
-					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
-					...SetOperatorRestSelect<Rest, TResult>,
-				]
-			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
-		: never
+		? Rest extends AnyPgSetOperatorInterface[] ? [
+				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
+				...SetOperatorRestSelect<Rest, TResult>,
+			]
+		: ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>[]>
 	: never
 	: TValue;
 

From af5387f7892de63157436a8b3c56f57b570e6516 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Mon, 30 Oct 2023 23:29:12 -0400
Subject: [PATCH 64/72] [SQLite] Types simplification from review

---
 .../query-builders/select.types.ts            | 69 ++++++-------------
 1 file changed, 20 insertions(+), 49 deletions(-)

diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index 32b47486a..3e8b4359f 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -192,26 +192,15 @@ export interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
 	>;
 }
 
-export type SQLiteSetOperatorExcludedMethods = Exclude<
-	keyof AnySQLiteSelectQueryBuilder,
-	// Only add the methods that a SetOperator is supposed to have
-	| 'orderBy'
-	| 'limit'
-	| 'offset'
-	| 'union'
-	| 'unionAll'
-	| 'intersect'
-	| 'intersectAll'
-	| 'except'
-	| 'exceptAll'
-	| '_'
-	| 'getSQL'
-	| 'as'
-	| 'addSetOperators'
-	| 'toSQL'
-	| '$dynamic'
-	| 'getSelectedFields'
->;
+export type SQLiteSetOperatorExcludedMethods =
+	| 'config'
+	| 'leftJoin'
+	| 'rightJoin'
+	| 'innerJoin'
+	| 'fullJoin'
+	| 'where'
+	| 'having'
+	| 'groupBy';
 
 export type CreateSQLiteSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
@@ -337,23 +326,7 @@ export interface SQLiteSetOperatorInterface<
 	TExcludedMethods extends string = never,
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends
-	Pick<
-		SQLiteSelectBase<
-			TTableName,
-			TResultType,
-			TRunResult,
-			TSelection,
-			TSelectMode,
-			TNullabilityMap,
-			TDynamic,
-			TExcludedMethods,
-			TResult,
-			TSelectedFields
-		>,
-		never
-	>
-{
+> {
 	_: {
 		readonly hkt: SQLiteSelectHKTBase;
 		readonly tableName: TTableName;
@@ -415,12 +388,11 @@ export type SetOperatorRightSelect<
 	TValue extends SQLiteSetOperatorWithResult<TResult>,
 	TResult extends any[],
 > = TValue extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
-	? TValueResult extends Array<infer TValueObj> ? ValidateShape<
-			TValueObj,
-			TResult[number],
-			TypedQueryBuilder<any, TValueResult>
-		>
-	: never
+	? ValidateShape<
+		TValueResult[number],
+		TResult[number],
+		TypedQueryBuilder<any, TValueResult>
+	>
 	: TValue;
 
 export type SetOperatorRestSelect<
@@ -428,12 +400,11 @@ export type SetOperatorRestSelect<
 	TResult extends any[],
 > = TValue extends [infer First, ...infer Rest]
 	? First extends SQLiteSetOperatorInterface<any, any, any, any, any, any, any, any, infer TValueResult, any>
-		? TValueResult extends Array<infer TValueObj> ? Rest extends AnySQLiteSetOperatorInterface[] ? [
-					ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>>,
-					...SetOperatorRestSelect<Rest, TResult>,
-				]
-			: ValidateShape<TValueObj, TResult[number], TypedQueryBuilder<any, TValueResult>[]>
-		: never
+		? Rest extends AnySQLiteSetOperatorInterface[] ? [
+				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
+				...SetOperatorRestSelect<Rest, TResult>,
+			]
+		: ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>[]>
 	: never
 	: TValue;
 

From a83ea7dadf147d89d6d35c4128bea0aed10e01a5 Mon Sep 17 00:00:00 2001
From: Angelelz <angellopez20@gmail.com>
Date: Mon, 30 Oct 2023 23:40:34 -0400
Subject: [PATCH 65/72] [MySql] fixed failing tests based on query order

---
 integration-tests/tests/mysql.test.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/integration-tests/tests/mysql.test.ts b/integration-tests/tests/mysql.test.ts
index 6028a299a..3b545fcd8 100644
--- a/integration-tests/tests/mysql.test.ts
+++ b/integration-tests/tests/mysql.test.ts
@@ -2537,7 +2537,7 @@ test.serial('set operations (except all) as function', async (t) => {
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 1)),
-	).limit(6);
+	).limit(6).orderBy(asc(sql.identifier('id')));
 
 	t.assert(result.length === 6);
 
@@ -2616,7 +2616,7 @@ test.serial('set operations (mixed all) as function with subquery', async (t) =>
 		db
 			.select({ id: users2Table.id, name: users2Table.name })
 			.from(users2Table).where(eq(users2Table.id, 7)),
-	).as('sq');
+	).orderBy(asc(sql.identifier('id'))).as('sq');
 
 	const result = await union(
 		db

From 6d0c2c094a49735215a12efd03ed6483c0ee70c3 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Sun, 5 Nov 2023 16:23:28 +0200
Subject: [PATCH 66/72] Fix cycle imports

---
 changelogs/drizzle-orm/0.29.0.md              | 259 +++++++++++++++---
 drizzle-orm/src/alias.ts                      |   4 +-
 drizzle-orm/src/aws-data-api/common/index.ts  |   2 +-
 drizzle-orm/src/aws-data-api/pg/session.ts    |   2 +-
 drizzle-orm/src/better-sqlite3/session.ts     |   2 +-
 drizzle-orm/src/bun-sqlite/session.ts         |   2 +-
 drizzle-orm/src/column-builder.ts             |   2 +-
 drizzle-orm/src/column.ts                     |   2 +-
 drizzle-orm/src/d1/session.ts                 |   3 +-
 drizzle-orm/src/index.ts                      |   1 -
 drizzle-orm/src/libsql/session.ts             |   2 +-
 drizzle-orm/src/mysql-core/alias.ts           |   2 +-
 drizzle-orm/src/mysql-core/checks.ts          |   2 +-
 drizzle-orm/src/mysql-core/columns/custom.ts  |   2 +-
 .../src/mysql-core/columns/date.common.ts     |   2 +-
 drizzle-orm/src/mysql-core/db.ts              |   6 +-
 drizzle-orm/src/mysql-core/dialect.ts         |  15 +-
 drizzle-orm/src/mysql-core/expressions.ts     |   4 +-
 drizzle-orm/src/mysql-core/indexes.ts         |   2 +-
 .../src/mysql-core/query-builders/delete.ts   |   2 +-
 .../src/mysql-core/query-builders/insert.ts   |   4 +-
 .../query-builders/query-builder.ts           |   5 +-
 .../src/mysql-core/query-builders/query.ts    |   2 +-
 .../src/mysql-core/query-builders/select.ts   |   9 +-
 .../mysql-core/query-builders/select.types.ts |   6 +-
 .../src/mysql-core/query-builders/update.ts   |   2 +-
 drizzle-orm/src/mysql-core/session.ts         |   2 +-
 drizzle-orm/src/mysql-core/subquery.ts        |   2 +-
 drizzle-orm/src/mysql-core/view-base.ts       |  15 +
 drizzle-orm/src/mysql-core/view.ts            |  20 +-
 drizzle-orm/src/mysql-proxy/migrator.ts       |   2 +-
 drizzle-orm/src/mysql-proxy/session.ts        |   4 +-
 drizzle-orm/src/mysql2/session.ts             |   2 +-
 drizzle-orm/src/neon-http/migrator.ts         |   2 +-
 drizzle-orm/src/neon-http/session.ts          |   2 +-
 drizzle-orm/src/neon-serverless/session.ts    |   2 +-
 drizzle-orm/src/node-postgres/session.ts      |   2 +-
 drizzle-orm/src/operations.ts                 |   2 +-
 drizzle-orm/src/pg-core/alias.ts              |   2 +-
 drizzle-orm/src/pg-core/columns/common.ts     |   3 +-
 drizzle-orm/src/pg-core/columns/custom.ts     |   2 +-
 .../src/pg-core/columns/date.common.ts        |   2 +-
 drizzle-orm/src/pg-core/columns/uuid.ts       |   2 +-
 drizzle-orm/src/pg-core/db.ts                 |   6 +-
 drizzle-orm/src/pg-core/dialect.ts            |   9 +-
 drizzle-orm/src/pg-core/expressions.ts        |   4 +-
 drizzle-orm/src/pg-core/indexes.ts            |   2 +-
 .../src/pg-core/query-builders/delete.ts      |   2 +-
 .../src/pg-core/query-builders/insert.ts      |   4 +-
 .../pg-core/query-builders/query-builder.ts   |   6 +-
 .../src/pg-core/query-builders/query.ts       |   2 +-
 .../refresh-materialized-view.ts              |   2 +-
 .../src/pg-core/query-builders/select.ts      |   9 +-
 .../pg-core/query-builders/select.types.ts    |   6 +-
 .../src/pg-core/query-builders/update.ts      |   2 +-
 drizzle-orm/src/pg-core/subquery.ts           |   2 +-
 drizzle-orm/src/pg-core/view-base.ts          |  14 +
 drizzle-orm/src/pg-core/view.ts               |  20 +-
 drizzle-orm/src/pg-proxy/migrator.ts          |   2 +-
 drizzle-orm/src/pg-proxy/session.ts           |   2 +-
 .../src/planetscale-serverless/session.ts     |   2 +-
 drizzle-orm/src/postgres-js/session.ts        |   2 +-
 .../src/query-builders/select.types.ts        |   3 +-
 drizzle-orm/src/relations.ts                  |   8 +-
 drizzle-orm/src/selection-proxy.ts            | 121 ++++++++
 drizzle-orm/src/sql-js/session.ts             |   2 +-
 drizzle-orm/src/sql/expressions/conditions.ts |   2 +-
 drizzle-orm/src/sql/sql.ts                    |  59 +++-
 drizzle-orm/src/sqlite-core/alias.ts          |   2 +-
 drizzle-orm/src/sqlite-core/checks.ts         |   2 +-
 drizzle-orm/src/sqlite-core/columns/custom.ts |   2 +-
 .../src/sqlite-core/columns/integer.ts        |   2 +-
 drizzle-orm/src/sqlite-core/db.ts             |   6 +-
 drizzle-orm/src/sqlite-core/dialect.ts        |   5 +-
 drizzle-orm/src/sqlite-core/expressions.ts    |   4 +-
 drizzle-orm/src/sqlite-core/indexes.ts        |   2 +-
 .../src/sqlite-core/query-builders/delete.ts  |   2 +-
 .../src/sqlite-core/query-builders/insert.ts  |   4 +-
 .../query-builders/query-builder.ts           |   5 +-
 .../src/sqlite-core/query-builders/query.ts   |   2 +-
 .../src/sqlite-core/query-builders/select.ts  |   9 +-
 .../query-builders/select.types.ts            |   6 +-
 .../src/sqlite-core/query-builders/update.ts  |   2 +-
 drizzle-orm/src/sqlite-core/session.ts        |   2 +-
 drizzle-orm/src/sqlite-core/subquery.ts       |   2 +-
 drizzle-orm/src/sqlite-core/view-base.ts      |  15 +
 drizzle-orm/src/sqlite-core/view.ts           |  18 +-
 drizzle-orm/src/sqlite-proxy/migrator.ts      |   2 +-
 drizzle-orm/src/sqlite-proxy/session.ts       |   2 +-
 drizzle-orm/src/subquery.ts                   | 135 +--------
 drizzle-orm/src/tracing-utils.ts              |   3 +
 drizzle-orm/src/tracing.ts                    |   2 +-
 drizzle-orm/src/utils.ts                      |   9 +-
 drizzle-orm/src/vercel-postgres/session.ts    |   2 +-
 drizzle-orm/src/view.ts                       |  58 ----
 drizzle-orm/type-tests/mysql/db-rel.ts        |   2 +-
 drizzle-orm/type-tests/mysql/delete.ts        |   2 +-
 drizzle-orm/type-tests/mysql/insert.ts        |   2 +-
 drizzle-orm/type-tests/mysql/select.ts        |   2 +-
 drizzle-orm/type-tests/mysql/subquery.ts      |   2 +-
 drizzle-orm/type-tests/mysql/tables.ts        |   2 +-
 drizzle-orm/type-tests/mysql/update.ts        |   2 +-
 drizzle-orm/type-tests/mysql/with.ts          |   2 +-
 drizzle-orm/type-tests/pg/db-rel.ts           |   2 +-
 drizzle-orm/type-tests/pg/delete.ts           |   2 +-
 drizzle-orm/type-tests/pg/insert.ts           |   2 +-
 drizzle-orm/type-tests/pg/other.ts            |   2 +-
 drizzle-orm/type-tests/pg/select.ts           |   2 +-
 drizzle-orm/type-tests/pg/subquery.ts         |   2 +-
 drizzle-orm/type-tests/pg/tables.ts           |   2 +-
 drizzle-orm/type-tests/pg/update.ts           |   2 +-
 drizzle-orm/type-tests/pg/with.ts             |   2 +-
 drizzle-orm/type-tests/sqlite/delete.ts       |   2 +-
 drizzle-orm/type-tests/sqlite/insert.ts       |   2 +-
 drizzle-orm/type-tests/sqlite/other.ts        |   2 +-
 drizzle-orm/type-tests/sqlite/select.ts       |   2 +-
 drizzle-orm/type-tests/sqlite/subquery.ts     |   2 +-
 drizzle-orm/type-tests/sqlite/tables.ts       |   2 +-
 drizzle-orm/type-tests/sqlite/update.ts       |   2 +-
 drizzle-orm/type-tests/sqlite/with.ts         |   2 +-
 integration-tests/.gitignore                  |   2 +
 integration-tests/package.json                |  12 +-
 integration-tests/tests/imports/index.test.ts |  55 ++++
 integration-tests/vitest.config.ts            |   2 +-
 pnpm-lock.yaml                                |  25 +-
 125 files changed, 708 insertions(+), 450 deletions(-)
 create mode 100644 drizzle-orm/src/mysql-core/view-base.ts
 create mode 100644 drizzle-orm/src/pg-core/view-base.ts
 create mode 100644 drizzle-orm/src/selection-proxy.ts
 create mode 100644 drizzle-orm/src/sqlite-core/view-base.ts
 create mode 100644 drizzle-orm/src/tracing-utils.ts
 delete mode 100644 drizzle-orm/src/view.ts
 create mode 100644 integration-tests/tests/imports/index.test.ts

diff --git a/changelogs/drizzle-orm/0.29.0.md b/changelogs/drizzle-orm/0.29.0.md
index daa86e5db..518c23e33 100644
--- a/changelogs/drizzle-orm/0.29.0.md
+++ b/changelogs/drizzle-orm/0.29.0.md
@@ -1,28 +1,213 @@
 ## New Features
 
-### MySQL `unsigned` option for bigint
+### 🎉 MySQL `unsigned` option for bigint
 
 You can now specify `bigint unsigned` type
 
 ```ts
 const table = mysqlTable('table', {
-	id: bigint('id', { mode: 'number', unsigned: true }),
+  id: bigint('id', { mode: 'number', unsigned: true }),
 });
 ```
 
-### Improved query builder types
+### 🎉 Improved query builder types
 
 Starting from `0.29.0` by default, as all the query builders in Drizzle try to conform to SQL as much as possible, you can only invoke most of the methods once. For example, in a SELECT statement there might only be one WHERE clause, so you can only invoke .where() once:
 
 ```ts
 const query = db
-	.select()
-	.from(users)
-	.where(eq(users.id, 1))
-	.where(eq(users.name, 'John')); // ❌ Type error - where() can only be invoked once
+  .select()
+  .from(users)
+  .where(eq(users.id, 1))
+  .where(eq(users.name, 'John')); // ❌ Type error - where() can only be invoked once
 ```
 
-### Possibility to specify name for primary keys and foreign keys
+This behavior is useful for conventional query building, i.e. when you create the whole query at once. However, it becomes a problem when you want to build a query dynamically, i.e. if you have a shared function that takes a query builder and enhances it. To solve this problem, Drizzle provides a special 'dynamic' mode for query builders, which removes the restriction of invoking methods only once. To enable it, you need to call .$dynamic() on a query builder.
+
+Let's see how it works by implementing a simple withPagination function that adds LIMIT and OFFSET clauses to a query based on the provided page number and an optional page size:
+
+```ts
+function withPagination<T extends PgSelect>(
+  qb: T,
+  page: number,
+  pageSize: number = 10,
+) {
+  return qb.limit(pageSize).offset(page * pageSize);
+}
+
+const query = db.select().from(users).where(eq(users.id, 1));
+withPagination(query, 1); // ❌ Type error - the query builder is not in dynamic mode
+
+const dynamicQuery = query.$dynamic();
+withPagination(dynamicQuery, 1); // ✅ OK
+```
+
+Note that the withPagination function is generic, which allows you to modify the result type of the query builder inside it, for example by adding a join:
+
+```ts
+function withFriends<T extends PgSelect>(qb: T) {
+  return qb.leftJoin(friends, eq(friends.userId, users.id));
+}
+
+let query = db.select().from(users).where(eq(users.id, 1)).$dynamic();
+query = withFriends(query);
+```
+
+### 🎉 Possibility to specify name for primary keys and foreign keys
+
+There is an issue when constraint names exceed the 64-character limit of the database. This causes the database engine to truncate the name, potentially leading to issues. Starting from `0.29.0`, you have the option to specify custom names for both `primaryKey()` and `foreignKey()`. We have also deprecated the old `primaryKey()` syntax, which can still be used but will be removed in future releases
+
+```ts
+const table = pgTable('table', {
+  id: integer('id'),
+  name: text('name'),
+}, (table) => ({
+  cpk: primaryKey({ name: 'composite_key', columns: [table.id, table.name] }),
+  cfk: foreignKey({
+    name: 'fkName',
+    columns: [table.id],
+    foreignColumns: [table.name],
+  }),
+}));
+```
+
+### 🎉 Read Replicas Support
+
+You can now use the Drizzle `withReplica` function to specify different database connections for read replicas and the main instance for write operations. By default, `withReplicas` will use a random read replica for read operations and the main instance for all other data modification operations. You can also specify custom logic for choosing which read replica connection to use. You have the freedom to make any weighted, custom decision for that. Here are some usage examples:
+
+```ts
+const primaryDb = drizzle(client);
+const read1 = drizzle(client);
+const read2 = drizzle(client);
+
+const db = withReplicas(primaryDb, [read1, read2]);
+
+// read from primary
+db.$primary.select().from(usersTable);
+
+// read from either read1 connection or read2 connection
+db.select().from(usersTable)
+
+// use primary database for delete operation
+db.delete(usersTable).where(eq(usersTable.id, 1))
+```
+
+Implementation example of custom logic for selecting read replicas, where the first replica has a 70% chance of being chosen, and the second replica has a 30% chance of being chosen. Note that you can implement any type of random selection for read replicas
+
+```ts
+const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
+    const weight = [0.7, 0.3];
+    let cumulativeProbability = 0;
+    const rand = Math.random();
+
+    for (const [i, replica] of replicas.entries()) {
+      cumulativeProbability += weight[i]!;
+      if (rand < cumulativeProbability) return replica;
+    }
+    return replicas[0]!
+});
+```
+
+`withReplicas` function is available for all dialects in Drizzle ORM
+
+### 🎉 New MySQL Proxy Driver
+
+A new driver has been released, allowing you to create your own implementation for an HTTP driver using a MySQL database. You can find usage examples in the `./examples/mysql-proxy` folder
+
+You need to implement two endpoints on your server that will be used for queries and migrations(Migrate endpoint is optional and only if you want to use drizzle migrations). Both the server and driver implementation are up to you, so you are not restricted in any way. You can add custom mappings, logging, and much more
+
+You can find both server and driver implementation examples in the `./examples/mysql-proxy` folder
+
+```ts
+// Driver
+import axios from 'axios';
+import { eq } from 'drizzle-orm/expressions';
+import { drizzle } from 'drizzle-orm/mysql-proxy';
+import { migrate } from 'drizzle-orm/mysql-proxy/migrator';
+import { cities, users } from './schema';
+
+async function main() {
+  const db = drizzle(async (sql, params, method) => {
+    try {
+      const rows = await axios.post(`${process.env.REMOTE_DRIVER}/query`, {
+        sql,
+        params,
+        method,
+      });
+
+      return { rows: rows.data };
+    } catch (e: any) {
+      console.error('Error from pg proxy server:', e.response.data);
+      return { rows: [] };
+    }
+  });
+
+  await migrate(db, async (queries) => {
+    try {
+      await axios.post(`${process.env.REMOTE_DRIVER}/migrate`, { queries });
+    } catch (e) {
+      console.log(e);
+      throw new Error('Proxy server cannot run migrations');
+    }
+  }, { migrationsFolder: 'drizzle' });
+
+  await db.insert(cities).values({ id: 1, name: 'name' });
+
+  await db.insert(users).values({
+    id: 1,
+    name: 'name',
+    email: 'email',
+    cityId: 1,
+  });
+
+  const usersToCityResponse = await db.select().from(users).leftJoin(
+    cities,
+    eq(users.cityId, cities.id),
+  );
+}
+```
+
+### 🎉 New PostgreSQL Proxy Driver
+
+Same as MySQL you can now implement your own http driver for PostgreSQL database. You can find usage examples in the `./examples/pg-proxy` folder
+
+You need to implement two endpoints on your server that will be used for queries and migrations (Migrate endpoint is optional and only if you want to use drizzle migrations). Both the server and driver implementation are up to you, so you are not restricted in any way. You can add custom mappings, logging, and much more
+
+You can find both server and driver implementation examples in the `./examples/pg-proxy` folder
+
+```ts
+import axios from 'axios';
+import { eq } from 'drizzle-orm/expressions';
+import { drizzle } from 'drizzle-orm/pg-proxy';
+import { migrate } from 'drizzle-orm/pg-proxy/migrator';
+import { cities, users } from './schema';
+
+async function main() {
+  const db = drizzle(async (sql, params, method) => {
+    try {
+      const rows = await axios.post(`${process.env.REMOTE_DRIVER}/query`, { sql, params, method });
+
+      return { rows: rows.data };
+    } catch (e: any) {
+      console.error('Error from pg proxy server:', e.response.data);
+      return { rows: [] };
+    }
+  });
+
+  await migrate(db, async (queries) => {
+    try {
+      await axios.post(`${process.env.REMOTE_DRIVER}/query`, { queries });
+    } catch (e) {
+      console.log(e);
+      throw new Error('Proxy server cannot run migrations');
+    }
+  }, { migrationsFolder: 'drizzle' });
+
+  const insertedCity = await db.insert(cities).values({ id: 1, name: 'name' }).returning();
+  const insertedUser = await db.insert(users).values({ id: 1, name: 'name', email: 'email', cityId: 1 });
+  const usersToCityResponse = await db.select().from(users).leftJoin(cities, eq(users.cityId, cities.id));
+}
+```
 
 ### 🎉 `D1` batch api support
 
@@ -32,15 +217,15 @@ Batch API usage example:
 
 ```ts
 const batchResponse = await db.batch([
-	db.insert(usersTable).values({ id: 1, name: 'John' }).returning({
-		id: usersTable.id,
-	}),
-	db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
-	db.query.usersTable.findMany({}),
-	db.select().from(usersTable).where(eq(usersTable.id, 1)),
-	db.select({ id: usersTable.id, invitedBy: usersTable.invitedBy }).from(
-		usersTable,
-	),
+  db.insert(usersTable).values({ id: 1, name: 'John' }).returning({
+    id: usersTable.id,
+  }),
+  db.update(usersTable).set({ name: 'Dan' }).where(eq(usersTable.id, 1)),
+  db.query.usersTable.findMany({}),
+  db.select().from(usersTable).where(eq(usersTable.id, 1)),
+  db.select({ id: usersTable.id, invitedBy: usersTable.invitedBy }).from(
+    usersTable,
+  ),
 ]);
 ```
 
@@ -48,26 +233,26 @@ Type for `batchResponse` in this example would be:
 
 ```ts
 type BatchResponse = [
-	{
-		id: number;
-	}[],
-	D1Result,
-	{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-	}[],
-	{
-		id: number;
-		name: string;
-		verified: number;
-		invitedBy: number | null;
-	}[],
-	{
-		id: number;
-		invitedBy: number | null;
-	}[],
+  {
+    id: number;
+  }[],
+  D1Result,
+  {
+    id: number;
+    name: string;
+    verified: number;
+    invitedBy: number | null;
+  }[],
+  {
+    id: number;
+    name: string;
+    verified: number;
+    invitedBy: number | null;
+  }[],
+  {
+    id: number;
+    invitedBy: number | null;
+  }[],
 ];
 ```
 
diff --git a/drizzle-orm/src/alias.ts b/drizzle-orm/src/alias.ts
index 06269921e..ecbc2dc56 100644
--- a/drizzle-orm/src/alias.ts
+++ b/drizzle-orm/src/alias.ts
@@ -2,10 +2,10 @@ import type { AnyColumn } from './column.ts';
 import { Column } from './column.ts';
 import { entityKind, is } from './entity.ts';
 import type { Relation } from './relations.ts';
-import { SQL, sql } from './sql/index.ts';
+import type { View} from './sql/sql.ts';
+import { SQL, sql } from './sql/sql.ts';
 import { Table } from './table.ts';
 import { ViewBaseConfig } from './view-common.ts';
-import type { View } from './view.ts';
 
 export class ColumnAliasProxyHandler<TColumn extends Column> implements ProxyHandler<TColumn> {
 	static readonly [entityKind]: string = 'ColumnAliasProxyHandler';
diff --git a/drizzle-orm/src/aws-data-api/common/index.ts b/drizzle-orm/src/aws-data-api/common/index.ts
index 805011941..9a657ba6c 100644
--- a/drizzle-orm/src/aws-data-api/common/index.ts
+++ b/drizzle-orm/src/aws-data-api/common/index.ts
@@ -1,6 +1,6 @@
 import type { Field } from '@aws-sdk/client-rds-data';
 import { TypeHint } from '@aws-sdk/client-rds-data';
-import type { QueryTypingsValue } from '~/sql/index.ts';
+import type { QueryTypingsValue } from '~/sql/sql.ts';
 
 export function getValueFromDataApi(field: Field) {
 	if (field.stringValue !== undefined) {
diff --git a/drizzle-orm/src/aws-data-api/pg/session.ts b/drizzle-orm/src/aws-data-api/pg/session.ts
index f52f4d0b3..53519e6b9 100644
--- a/drizzle-orm/src/aws-data-api/pg/session.ts
+++ b/drizzle-orm/src/aws-data-api/pg/session.ts
@@ -18,7 +18,7 @@ import {
 } from '~/pg-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type QueryTypingsValue, type QueryWithTypings, type SQL, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type QueryTypingsValue, type QueryWithTypings, type SQL, sql } from '~/sql/sql.ts';
 import { mapResultRow } from '~/utils.ts';
 import { getValueFromDataApi, toValueParam } from '../common/index.ts';
 
diff --git a/drizzle-orm/src/better-sqlite3/session.ts b/drizzle-orm/src/better-sqlite3/session.ts
index 64cf7b9dd..20d1612c2 100644
--- a/drizzle-orm/src/better-sqlite3/session.ts
+++ b/drizzle-orm/src/better-sqlite3/session.ts
@@ -3,7 +3,7 @@ import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
diff --git a/drizzle-orm/src/bun-sqlite/session.ts b/drizzle-orm/src/bun-sqlite/session.ts
index 3f8ac11de..612350a47 100644
--- a/drizzle-orm/src/bun-sqlite/session.ts
+++ b/drizzle-orm/src/bun-sqlite/session.ts
@@ -5,7 +5,7 @@ import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
diff --git a/drizzle-orm/src/column-builder.ts b/drizzle-orm/src/column-builder.ts
index 5adce6e73..7ef9b6d14 100644
--- a/drizzle-orm/src/column-builder.ts
+++ b/drizzle-orm/src/column-builder.ts
@@ -2,7 +2,7 @@ import { entityKind } from '~/entity.ts';
 import type { Column } from './column.ts';
 import type { MySqlColumn } from './mysql-core/index.ts';
 import type { PgColumn } from './pg-core/index.ts';
-import type { SQL } from './sql/index.ts';
+import type { SQL } from './sql/sql.ts';
 import type { SQLiteColumn } from './sqlite-core/index.ts';
 import type { Simplify } from './utils.ts';
 
diff --git a/drizzle-orm/src/column.ts b/drizzle-orm/src/column.ts
index 1582ba825..deacc073a 100644
--- a/drizzle-orm/src/column.ts
+++ b/drizzle-orm/src/column.ts
@@ -1,6 +1,6 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, ColumnDataType } from './column-builder.ts';
 import { entityKind } from './entity.ts';
-import type { DriverValueMapper, SQL, SQLWrapper } from './sql/index.ts';
+import type { DriverValueMapper, SQL, SQLWrapper } from './sql/sql.ts';
 import type { Table } from './table.ts';
 import type { Update } from './utils.ts';
 
diff --git a/drizzle-orm/src/d1/session.ts b/drizzle-orm/src/d1/session.ts
index 1de446f2c..da2040ec7 100644
--- a/drizzle-orm/src/d1/session.ts
+++ b/drizzle-orm/src/d1/session.ts
@@ -6,8 +6,7 @@ import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import type { PreparedQuery } from '~/session.ts';
-import { type Query, sql } from '~/sql/index.ts';
-import { fillPlaceholders } from '~/sql/index.ts';
+import { type Query, sql, fillPlaceholders } from '~/sql/sql.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
diff --git a/drizzle-orm/src/index.ts b/drizzle-orm/src/index.ts
index 66b45c585..bc72260b9 100644
--- a/drizzle-orm/src/index.ts
+++ b/drizzle-orm/src/index.ts
@@ -13,4 +13,3 @@ export * from './subquery.ts';
 export * from './table.ts';
 export * from './utils.ts';
 export * from './view-common.ts';
-export * from './view.ts';
diff --git a/drizzle-orm/src/libsql/session.ts b/drizzle-orm/src/libsql/session.ts
index e8fb7e24a..76155f041 100644
--- a/drizzle-orm/src/libsql/session.ts
+++ b/drizzle-orm/src/libsql/session.ts
@@ -5,7 +5,7 @@ import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import type { PreparedQuery } from '~/session.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
diff --git a/drizzle-orm/src/mysql-core/alias.ts b/drizzle-orm/src/mysql-core/alias.ts
index 59ab93dbb..8320c5533 100644
--- a/drizzle-orm/src/mysql-core/alias.ts
+++ b/drizzle-orm/src/mysql-core/alias.ts
@@ -1,7 +1,7 @@
 import { TableAliasProxyHandler } from '~/alias.ts';
 import type { BuildAliasTable } from './query-builders/select.types.ts';
 import type { MySqlTable } from './table.ts';
-import type { MySqlViewBase } from './view.ts';
+import type { MySqlViewBase } from './view-base.ts';
 
 export function alias<TTable extends MySqlTable | MySqlViewBase, TAlias extends string>(
 	table: TTable,
diff --git a/drizzle-orm/src/mysql-core/checks.ts b/drizzle-orm/src/mysql-core/checks.ts
index fa76b4537..af9a29f6a 100644
--- a/drizzle-orm/src/mysql-core/checks.ts
+++ b/drizzle-orm/src/mysql-core/checks.ts
@@ -1,5 +1,5 @@
 import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 import type { MySqlTable } from './table.ts';
 
 export class CheckBuilder {
diff --git a/drizzle-orm/src/mysql-core/columns/custom.ts b/drizzle-orm/src/mysql-core/columns/custom.ts
index 02d7b9c68..135bc8c09 100644
--- a/drizzle-orm/src/mysql-core/columns/custom.ts
+++ b/drizzle-orm/src/mysql-core/columns/custom.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 import type { Equal } from '~/utils.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
diff --git a/drizzle-orm/src/mysql-core/columns/date.common.ts b/drizzle-orm/src/mysql-core/columns/date.common.ts
index 9800a3d90..3fd8aa612 100644
--- a/drizzle-orm/src/mysql-core/columns/date.common.ts
+++ b/drizzle-orm/src/mysql-core/columns/date.common.ts
@@ -6,7 +6,7 @@ import type {
 } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
 
 export interface MySqlDateColumnBaseConfig {
diff --git a/drizzle-orm/src/mysql-core/db.ts b/drizzle-orm/src/mysql-core/db.ts
index f7bd76e0c..e3a07cee3 100644
--- a/drizzle-orm/src/mysql-core/db.ts
+++ b/drizzle-orm/src/mysql-core/db.ts
@@ -2,10 +2,8 @@ import type { ResultSetHeader } from 'mysql2/promise';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { SQLWrapper } from '~/sql/index.ts';
-import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
+import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
-import type { ColumnsSelection } from '~/view.ts';
 import type { MySqlDialect } from './dialect.ts';
 import {
 	MySqlDeleteBase,
@@ -27,6 +25,8 @@ import type {
 } from './session.ts';
 import type { WithSubqueryWithSelection } from './subquery.ts';
 import type { MySqlTable } from './table.ts';
+import { WithSubquery } from '~/subquery.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export class MySqlDatabase<
 	TQueryResult extends QueryResultHKT,
diff --git a/drizzle-orm/src/mysql-core/dialect.ts b/drizzle-orm/src/mysql-core/dialect.ts
index 03c567069..967016e1d 100644
--- a/drizzle-orm/src/mysql-core/dialect.ts
+++ b/drizzle-orm/src/mysql-core/dialect.ts
@@ -14,12 +14,11 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { and, eq, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
+import { Param, type QueryWithTypings, SQL, sql, type SQLChunk, View } from '~/sql/sql.ts';
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
-import { View } from '~/view.ts';
-import { DrizzleError, ViewBaseConfig } from '../index.ts';
+import { DrizzleError, ViewBaseConfig, and, eq } from '../index.ts';
 import { MySqlColumn } from './columns/common.ts';
 import type { MySqlDeleteConfig } from './query-builders/delete.ts';
 import type { MySqlInsertConfig } from './query-builders/insert.ts';
@@ -27,15 +26,7 @@ import type { MySqlSelectConfig, MySqlSelectJoinConfig, SelectedFieldsOrdered }
 import type { MySqlUpdateConfig } from './query-builders/update.ts';
 import type { MySqlSession } from './session.ts';
 import { MySqlTable } from './table.ts';
-import { MySqlViewBase } from './view.ts';
-
-// TODO find out how to use all/values. Seems like I need those functions
-// Build project
-// copy runtime tests to be sure it's working
-
-// Add mysql to drizzle-kit
-
-// Add Planetscale Driver and create example repo
+import { MySqlViewBase } from './view-base.ts';
 
 export class MySqlDialect {
 	static readonly [entityKind]: string = 'MySqlDialect';
diff --git a/drizzle-orm/src/mysql-core/expressions.ts b/drizzle-orm/src/mysql-core/expressions.ts
index 76db28551..a61f77786 100644
--- a/drizzle-orm/src/mysql-core/expressions.ts
+++ b/drizzle-orm/src/mysql-core/expressions.ts
@@ -1,6 +1,6 @@
 import { bindIfParam } from '~/expressions.ts';
-import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/index.ts';
-import { sql } from '~/sql/index.ts';
+import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
+import { sql } from '~/sql/sql.ts';
 import type { MySqlColumn } from './columns/index.ts';
 
 export * from '~/expressions.ts';
diff --git a/drizzle-orm/src/mysql-core/indexes.ts b/drizzle-orm/src/mysql-core/indexes.ts
index 8a6139e1e..5b73b1d30 100644
--- a/drizzle-orm/src/mysql-core/indexes.ts
+++ b/drizzle-orm/src/mysql-core/indexes.ts
@@ -1,5 +1,5 @@
 import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 import type { AnyMySqlColumn, MySqlColumn } from './columns/index.ts';
 import type { MySqlTable } from './table.ts';
 
diff --git a/drizzle-orm/src/mysql-core/query-builders/delete.ts b/drizzle-orm/src/mysql-core/query-builders/delete.ts
index b8f5a36fd..33588fd16 100644
--- a/drizzle-orm/src/mysql-core/query-builders/delete.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/delete.ts
@@ -11,7 +11,7 @@ import type {
 } from '~/mysql-core/session.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { SelectedFieldsOrdered } from './select.types.ts';
 
 export type MySqlDeleteWithout<
diff --git a/drizzle-orm/src/mysql-core/query-builders/insert.ts b/drizzle-orm/src/mysql-core/query-builders/insert.ts
index ddb593aa7..4a007d06d 100644
--- a/drizzle-orm/src/mysql-core/query-builders/insert.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/insert.ts
@@ -11,8 +11,8 @@ import type {
 } from '~/mysql-core/session.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { Placeholder, Query, SQLWrapper } from '~/sql/index.ts';
-import { Param, SQL, sql } from '~/sql/index.ts';
+import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { Param, SQL, sql } from '~/sql/sql.ts';
 import { Table } from '~/table.ts';
 import { mapUpdateSet } from '~/utils.ts';
 import type { MySqlUpdateSetSource } from './update.ts';
diff --git a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
index a145f65b3..9cb5ca9e2 100644
--- a/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/query-builder.ts
@@ -2,10 +2,11 @@ import { entityKind } from '~/entity.ts';
 import { MySqlDialect } from '~/mysql-core/dialect.ts';
 import type { WithSubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import type { ColumnsSelection } from '~/view.ts';
 import { MySqlSelectBuilder } from './select.ts';
 import type { SelectedFields } from './select.types.ts';
+import { WithSubquery } from '~/subquery.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
 
 export class QueryBuilder {
 	static readonly [entityKind]: string = 'MySqlQueryBuilder';
diff --git a/drizzle-orm/src/mysql-core/query-builders/query.ts b/drizzle-orm/src/mysql-core/query-builders/query.ts
index 3b28b1888..f14a5a74e 100644
--- a/drizzle-orm/src/mysql-core/query-builders/query.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/query.ts
@@ -8,7 +8,7 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import type { Query, QueryWithTypings, SQL } from '~/sql/index.ts';
+import type { Query, QueryWithTypings, SQL } from '~/sql/sql.ts';
 import type { KnownKeysOnly } from '~/utils.ts';
 import type { MySqlDialect } from '../dialect.ts';
 import type { Mode, MySqlSession, PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.ts b/drizzle-orm/src/mysql-core/query-builders/select.ts
index 4dd4f5cda..ff2736fca 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.ts
@@ -4,7 +4,6 @@ import type { MySqlDialect } from '~/mysql-core/dialect.ts';
 import type { MySqlSession, PreparedQueryConfig, PreparedQueryHKTBase } from '~/mysql-core/session.ts';
 import type { SubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
-import { MySqlViewBase } from '~/mysql-core/view.ts';
 import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
@@ -16,13 +15,15 @@ import type {
 	SelectResult,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import { type Query, SQL } from '~/sql/index.ts';
-import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { ColumnsSelection, Query } from '~/sql/sql.ts';
+import { SQL, View } from '~/sql/sql.ts';
+import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
 import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } from '~/utils.ts';
 import { orderSelectedFields } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import { type ColumnsSelection, View } from '~/view.ts';
+import { MySqlViewBase } from '../view-base.ts';
 import type {
 	CreateMySqlSelectFromBuilderMode,
 	LockConfig,
diff --git a/drizzle-orm/src/mysql-core/query-builders/select.types.ts b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
index 529ce0e5d..ddb22758a 100644
--- a/drizzle-orm/src/mysql-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/select.types.ts
@@ -1,6 +1,5 @@
 import type { MySqlColumn } from '~/mysql-core/columns/index.ts';
 import type { MySqlTable, MySqlTableWithColumns } from '~/mysql-core/table.ts';
-import type { MySqlViewBase, MySqlViewWithSelection } from '~/mysql-core/view.ts';
 import type {
 	SelectedFields as SelectedFieldsBase,
 	SelectedFieldsFlat as SelectedFieldsFlatBase,
@@ -17,13 +16,14 @@ import type {
 	SelectMode,
 	SelectResult,
 } from '~/query-builders/select.types.ts';
-import type { Placeholder, SQL } from '~/sql/index.ts';
+import type { ColumnsSelection, Placeholder, SQL, View } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import type { Assume } from '~/utils.ts';
-import type { ColumnsSelection, View } from '~/view.ts';
 import type { PreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
 import type { MySqlSelectBase, MySqlSelectQueryBuilderBase } from './select.ts';
+import type { MySqlViewBase } from '../view-base.ts';
+import type { MySqlViewWithSelection } from '../view.ts';
 
 export interface MySqlSelectJoinConfig {
 	on: SQL | undefined;
diff --git a/drizzle-orm/src/mysql-core/query-builders/update.ts b/drizzle-orm/src/mysql-core/query-builders/update.ts
index 5bedea7b9..94b884058 100644
--- a/drizzle-orm/src/mysql-core/query-builders/update.ts
+++ b/drizzle-orm/src/mysql-core/query-builders/update.ts
@@ -12,7 +12,7 @@ import type {
 } from '~/mysql-core/session.ts';
 import type { MySqlTable } from '~/mysql-core/table.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import { mapUpdateSet, type UpdateSet } from '~/utils.ts';
 import type { SelectedFieldsOrdered } from './select.types.ts';
 
diff --git a/drizzle-orm/src/mysql-core/session.ts b/drizzle-orm/src/mysql-core/session.ts
index 82320e0e1..528782d7b 100644
--- a/drizzle-orm/src/mysql-core/session.ts
+++ b/drizzle-orm/src/mysql-core/session.ts
@@ -1,7 +1,7 @@
 import { entityKind } from '~/entity.ts';
 import { TransactionRollbackError } from '~/errors.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { type Query, type SQL, sql } from '~/sql/index.ts';
+import { type Query, type SQL, sql } from '~/sql/sql.ts';
 import type { Assume, Equal } from '~/utils.ts';
 import { MySqlDatabase } from './db.ts';
 import type { MySqlDialect } from './dialect.ts';
diff --git a/drizzle-orm/src/mysql-core/subquery.ts b/drizzle-orm/src/mysql-core/subquery.ts
index 3a7378ba2..9d2c1828c 100644
--- a/drizzle-orm/src/mysql-core/subquery.ts
+++ b/drizzle-orm/src/mysql-core/subquery.ts
@@ -1,6 +1,6 @@
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
 import type { Subquery, WithSubquery } from '~/subquery.ts';
-import type { ColumnsSelection } from '~/view.ts';
 
 export type SubqueryWithSelection<
 	TSelection extends ColumnsSelection,
diff --git a/drizzle-orm/src/mysql-core/view-base.ts b/drizzle-orm/src/mysql-core/view-base.ts
new file mode 100644
index 000000000..53c9e38c2
--- /dev/null
+++ b/drizzle-orm/src/mysql-core/view-base.ts
@@ -0,0 +1,15 @@
+import { entityKind } from '~/entity.ts';
+import type { ColumnsSelection} from '~/sql/sql.ts';
+import { View } from '~/sql/sql.ts';
+
+export abstract class MySqlViewBase<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> extends View<TName, TExisting, TSelectedFields> {
+	static readonly [entityKind]: string = 'MySqlViewBase';
+
+	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
+		readonly viewBrand: 'MySqlViewBase';
+	};
+}
diff --git a/drizzle-orm/src/mysql-core/view.ts b/drizzle-orm/src/mysql-core/view.ts
index fda47b231..dd7d2f82d 100644
--- a/drizzle-orm/src/mysql-core/view.ts
+++ b/drizzle-orm/src/mysql-core/view.ts
@@ -2,15 +2,15 @@ import type { BuildColumns } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
-import type { SQL } from '~/sql/index.ts';
-import { SelectionProxyHandler } from '~/subquery.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
-import { type ColumnsSelection, View } from '~/view.ts';
 import type { MySqlColumn, MySqlColumnBuilderBase } from './columns/index.ts';
-import { QueryBuilder } from './query-builders/index.ts';
+import { QueryBuilder } from './query-builders/query-builder.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { mysqlTable } from './table.ts';
 import { MySqlViewConfig } from './view-common.ts';
+import { MySqlViewBase } from './view-base.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export interface ViewBuilderConfig {
 	algorithm?: 'undefined' | 'merge' | 'temptable';
@@ -152,18 +152,6 @@ export class ManualViewBuilder<
 	}
 }
 
-export abstract class MySqlViewBase<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> extends View<TName, TExisting, TSelectedFields> {
-	static readonly [entityKind]: string = 'MySqlViewBase';
-
-	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
-		readonly viewBrand: 'MySqlViewBase';
-	};
-}
-
 export class MySqlView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
diff --git a/drizzle-orm/src/mysql-proxy/migrator.ts b/drizzle-orm/src/mysql-proxy/migrator.ts
index f071888c7..b75184934 100644
--- a/drizzle-orm/src/mysql-proxy/migrator.ts
+++ b/drizzle-orm/src/mysql-proxy/migrator.ts
@@ -1,6 +1,6 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { MySqlRemoteDatabase } from './driver.ts';
 
 export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
diff --git a/drizzle-orm/src/mysql-proxy/session.ts b/drizzle-orm/src/mysql-proxy/session.ts
index 4d9a7b16a..973cb2393 100644
--- a/drizzle-orm/src/mysql-proxy/session.ts
+++ b/drizzle-orm/src/mysql-proxy/session.ts
@@ -14,8 +14,8 @@ import type {
 } from '~/mysql-core/session.ts';
 import { MySqlSession, PreparedQuery as PreparedQueryBase } from '~/mysql-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders } from '~/sql/index.ts';
-import type { Query, SQL } from '~/sql/index.ts';
+import { fillPlaceholders } from '~/sql/sql.ts';
+import type { Query, SQL } from '~/sql/sql.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 import type { RemoteCallback } from './driver.ts';
 
diff --git a/drizzle-orm/src/mysql2/session.ts b/drizzle-orm/src/mysql2/session.ts
index 13e25c812..3d3e535d6 100644
--- a/drizzle-orm/src/mysql2/session.ts
+++ b/drizzle-orm/src/mysql2/session.ts
@@ -27,7 +27,7 @@ import {
 	type QueryResultHKT,
 } from '~/mysql-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
 export type MySql2Client = Pool | Connection;
diff --git a/drizzle-orm/src/neon-http/migrator.ts b/drizzle-orm/src/neon-http/migrator.ts
index e4b00d27a..ffda77760 100644
--- a/drizzle-orm/src/neon-http/migrator.ts
+++ b/drizzle-orm/src/neon-http/migrator.ts
@@ -1,6 +1,6 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
-import { type SQL, sql } from '~/sql/index.ts';
+import { type SQL, sql } from '~/sql/sql.ts';
 import type { NeonHttpDatabase } from './driver.ts';
 
 /**
diff --git a/drizzle-orm/src/neon-http/session.ts b/drizzle-orm/src/neon-http/session.ts
index 9609412e4..9b73ab98c 100644
--- a/drizzle-orm/src/neon-http/session.ts
+++ b/drizzle-orm/src/neon-http/session.ts
@@ -8,7 +8,7 @@ import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.type
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query } from '~/sql/index.ts';
+import { fillPlaceholders, type Query } from '~/sql/sql.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
 export type NeonHttpClient = {
diff --git a/drizzle-orm/src/neon-serverless/session.ts b/drizzle-orm/src/neon-serverless/session.ts
index c49319bb4..891835259 100644
--- a/drizzle-orm/src/neon-serverless/session.ts
+++ b/drizzle-orm/src/neon-serverless/session.ts
@@ -16,7 +16,7 @@ import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.type
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
 export type NeonClient = Pool | PoolClient | Client;
diff --git a/drizzle-orm/src/node-postgres/session.ts b/drizzle-orm/src/node-postgres/session.ts
index 6167ee16b..01ad7cac8 100644
--- a/drizzle-orm/src/node-postgres/session.ts
+++ b/drizzle-orm/src/node-postgres/session.ts
@@ -8,7 +8,7 @@ import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.type
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import { tracer } from '~/tracing.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
diff --git a/drizzle-orm/src/operations.ts b/drizzle-orm/src/operations.ts
index 19927cd94..09cf41b8a 100644
--- a/drizzle-orm/src/operations.ts
+++ b/drizzle-orm/src/operations.ts
@@ -1,5 +1,5 @@
 import type { AnyColumn, Column } from './column.ts';
-import type { SQL } from './sql/index.ts';
+import type { SQL } from './sql/sql.ts';
 import type { Table } from './table.ts';
 
 export type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
diff --git a/drizzle-orm/src/pg-core/alias.ts b/drizzle-orm/src/pg-core/alias.ts
index 89e8255c1..53bbf5d43 100644
--- a/drizzle-orm/src/pg-core/alias.ts
+++ b/drizzle-orm/src/pg-core/alias.ts
@@ -2,7 +2,7 @@ import { TableAliasProxyHandler } from '~/alias.ts';
 import type { BuildAliasTable } from './query-builders/select.types.ts';
 
 import type { PgTable } from './table.ts';
-import type { PgViewBase } from './view.ts';
+import type { PgViewBase } from './view-base.ts';
 
 export function alias<TTable extends PgTable | PgViewBase, TAlias extends string>(
 	table: TTable,
diff --git a/drizzle-orm/src/pg-core/columns/common.ts b/drizzle-orm/src/pg-core/columns/common.ts
index 94f7d2310..17ba6b929 100644
--- a/drizzle-orm/src/pg-core/columns/common.ts
+++ b/drizzle-orm/src/pg-core/columns/common.ts
@@ -10,13 +10,14 @@ import { ColumnBuilder } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { Column } from '~/column.ts';
 import { entityKind, is } from '~/entity.ts';
-import { iife, type Update } from '~/utils.ts';
+import type { Update } from '~/utils.ts';
 
 import type { ForeignKey, UpdateDeleteAction } from '~/pg-core/foreign-keys.ts';
 import { ForeignKeyBuilder } from '~/pg-core/foreign-keys.ts';
 import type { AnyPgTable, PgTable } from '~/pg-core/table.ts';
 import { uniqueKeyName } from '../unique-constraint.ts';
 import { makePgArray, parsePgArray } from '../utils/array.ts';
+import { iife } from '~/tracing-utils.ts';
 
 export interface ReferenceConfig {
 	ref: () => PgColumn;
diff --git a/drizzle-orm/src/pg-core/columns/custom.ts b/drizzle-orm/src/pg-core/columns/custom.ts
index 43492669a..7af6c73d1 100644
--- a/drizzle-orm/src/pg-core/columns/custom.ts
+++ b/drizzle-orm/src/pg-core/columns/custom.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 import type { Equal } from '~/utils.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
diff --git a/drizzle-orm/src/pg-core/columns/date.common.ts b/drizzle-orm/src/pg-core/columns/date.common.ts
index afae5bb67..c2a46d1ce 100644
--- a/drizzle-orm/src/pg-core/columns/date.common.ts
+++ b/drizzle-orm/src/pg-core/columns/date.common.ts
@@ -1,6 +1,6 @@
 import type { ColumnBuilderBaseConfig, ColumnDataType } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { PgColumnBuilder } from './common.ts';
 
 export abstract class PgDateColumnBaseBuilder<
diff --git a/drizzle-orm/src/pg-core/columns/uuid.ts b/drizzle-orm/src/pg-core/columns/uuid.ts
index f9fe9e808..4c9ba04ed 100644
--- a/drizzle-orm/src/pg-core/columns/uuid.ts
+++ b/drizzle-orm/src/pg-core/columns/uuid.ts
@@ -2,7 +2,7 @@ import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnCon
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import type { AnyPgTable } from '~/pg-core/table.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { PgColumn, PgColumnBuilder } from './common.ts';
 
 export type PgUUIDBuilderInitial<TName extends string> = PgUUIDBuilder<{
diff --git a/drizzle-orm/src/pg-core/db.ts b/drizzle-orm/src/pg-core/db.ts
index 6e66e8ca7..8a1be58de 100644
--- a/drizzle-orm/src/pg-core/db.ts
+++ b/drizzle-orm/src/pg-core/db.ts
@@ -17,16 +17,16 @@ import type {
 import type { PgTable } from '~/pg-core/table.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { SQLWrapper } from '~/sql/index.ts';
-import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
+import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
-import type { ColumnsSelection } from '~/view.ts';
 import type { PgColumn } from './columns/index.ts';
 import { RelationalQueryBuilder } from './query-builders/query.ts';
 import { PgRefreshMaterializedView } from './query-builders/refresh-materialized-view.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import type { WithSubqueryWithSelection } from './subquery.ts';
 import type { PgMaterializedView } from './view.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export class PgDatabase<
 	TQueryResult extends QueryResultHKT,
diff --git a/drizzle-orm/src/pg-core/dialect.ts b/drizzle-orm/src/pg-core/dialect.ts
index 6f5305568..651ac0d39 100644
--- a/drizzle-orm/src/pg-core/dialect.ts
+++ b/drizzle-orm/src/pg-core/dialect.ts
@@ -24,23 +24,22 @@ import {
 	type TablesRelationalConfig,
 } from '~/relations.ts';
 import {
-	and,
 	type DriverValueEncoder,
-	eq,
 	Param,
 	type QueryTypingsValue,
 	type QueryWithTypings,
 	SQL,
 	sql,
 	type SQLChunk,
-} from '~/sql/index.ts';
+} from '~/sql/sql.ts';
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { getTableName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import { View } from '~/view.ts';
 import type { PgSession } from './session.ts';
-import { type PgMaterializedView, PgViewBase } from './view.ts';
+import type { PgMaterializedView } from './view.ts';
+import { View, and, eq } from '~/sql/index.ts';
+import { PgViewBase } from './view-base.ts';
 
 export class PgDialect {
 	static readonly [entityKind]: string = 'PgDialect';
diff --git a/drizzle-orm/src/pg-core/expressions.ts b/drizzle-orm/src/pg-core/expressions.ts
index e410587b4..88f494633 100644
--- a/drizzle-orm/src/pg-core/expressions.ts
+++ b/drizzle-orm/src/pg-core/expressions.ts
@@ -1,7 +1,7 @@
 import { bindIfParam } from '~/expressions.ts';
 import type { PgColumn } from '~/pg-core/columns/index.ts';
-import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/index.ts';
-import { sql } from '~/sql/index.ts';
+import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
+import { sql } from '~/sql/sql.ts';
 
 export * from '~/expressions.ts';
 
diff --git a/drizzle-orm/src/pg-core/indexes.ts b/drizzle-orm/src/pg-core/indexes.ts
index d4ecaf535..a719d44fe 100644
--- a/drizzle-orm/src/pg-core/indexes.ts
+++ b/drizzle-orm/src/pg-core/indexes.ts
@@ -1,4 +1,4 @@
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 
 import { entityKind } from '~/entity.ts';
 import type { PgColumn } from './columns/index.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/delete.ts b/drizzle-orm/src/pg-core/query-builders/delete.ts
index 28dfaba09..5f446e03f 100644
--- a/drizzle-orm/src/pg-core/query-builders/delete.ts
+++ b/drizzle-orm/src/pg-core/query-builders/delete.ts
@@ -10,7 +10,7 @@ import type {
 import type { PgTable } from '~/pg-core/table.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import { Table } from '~/table.ts';
 import { tracer } from '~/tracing.ts';
 import { orderSelectedFields } from '~/utils.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/insert.ts b/drizzle-orm/src/pg-core/query-builders/insert.ts
index 93bf3aa43..b886426be 100644
--- a/drizzle-orm/src/pg-core/query-builders/insert.ts
+++ b/drizzle-orm/src/pg-core/query-builders/insert.ts
@@ -11,8 +11,8 @@ import type {
 import type { PgTable } from '~/pg-core/table.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { Placeholder, Query, SQLWrapper } from '~/sql/index.ts';
-import { Param, SQL, sql } from '~/sql/index.ts';
+import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { Param, SQL, sql } from '~/sql/sql.ts';
 import { Table } from '~/table.ts';
 import { tracer } from '~/tracing.ts';
 import { mapUpdateSet, orderSelectedFields } from '~/utils.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/query-builder.ts b/drizzle-orm/src/pg-core/query-builders/query-builder.ts
index f1d208574..755f54251 100644
--- a/drizzle-orm/src/pg-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/pg-core/query-builders/query-builder.ts
@@ -1,13 +1,13 @@
 import { entityKind } from '~/entity.ts';
 import { PgDialect } from '~/pg-core/dialect.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
-import type { SQLWrapper } from '~/sql/index.ts';
-import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import type { ColumnsSelection } from '~/view.ts';
+import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
 import type { PgColumn } from '../columns/index.ts';
 import type { WithSubqueryWithSelection } from '../subquery.ts';
 import { PgSelectBuilder } from './select.ts';
 import type { SelectedFields } from './select.types.ts';
+import { WithSubquery } from '~/subquery.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export class QueryBuilder {
 	static readonly [entityKind]: string = 'PgQueryBuilder';
diff --git a/drizzle-orm/src/pg-core/query-builders/query.ts b/drizzle-orm/src/pg-core/query-builders/query.ts
index 70272f982..ab0a99839 100644
--- a/drizzle-orm/src/pg-core/query-builders/query.ts
+++ b/drizzle-orm/src/pg-core/query-builders/query.ts
@@ -8,7 +8,7 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import type { Query, QueryWithTypings, SQL } from '~/sql/index.ts';
+import type { Query, QueryWithTypings, SQL } from '~/sql/sql.ts';
 import { tracer } from '~/tracing.ts';
 import type { KnownKeysOnly } from '~/utils.ts';
 import type { PgDialect } from '../dialect.ts';
diff --git a/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts b/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts
index 48127360f..3ce015793 100644
--- a/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts
+++ b/drizzle-orm/src/pg-core/query-builders/refresh-materialized-view.ts
@@ -9,7 +9,7 @@ import type {
 } from '~/pg-core/session.ts';
 import type { PgMaterializedView } from '~/pg-core/view.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { Query, SQL } from '~/sql/index.ts';
+import type { Query, SQL } from '~/sql/sql.ts';
 import { tracer } from '~/tracing.ts';
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
diff --git a/drizzle-orm/src/pg-core/query-builders/select.ts b/drizzle-orm/src/pg-core/query-builders/select.ts
index f954f3340..a1d7caec5 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.ts
@@ -4,7 +4,7 @@ import type { PgDialect } from '~/pg-core/dialect.ts';
 import type { PgSession, PreparedQueryConfig } from '~/pg-core/session.ts';
 import type { SubqueryWithSelection } from '~/pg-core/subquery.ts';
 import type { PgTable } from '~/pg-core/table.ts';
-import { PgViewBase } from '~/pg-core/view.ts';
+import { PgViewBase } from '~/pg-core/view-base.ts';
 import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
@@ -16,14 +16,15 @@ import type {
 	SelectResult,
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import { type Placeholder, type Query, SQL, type SQLWrapper } from '~/sql/index.ts';
-import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { SQL, View } from '~/sql/sql.ts';
+import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
 import { tracer } from '~/tracing.ts';
 import { applyMixins, getTableColumns, getTableLikeName, type ValueOrArray } from '~/utils.ts';
 import { orderSelectedFields } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import { type ColumnsSelection, View } from '~/view.ts';
 import type {
 	CreatePgSelectFromBuilderMode,
 	LockConfig,
diff --git a/drizzle-orm/src/pg-core/query-builders/select.types.ts b/drizzle-orm/src/pg-core/query-builders/select.types.ts
index 949736a3a..6877f2be5 100644
--- a/drizzle-orm/src/pg-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/pg-core/query-builders/select.types.ts
@@ -5,7 +5,8 @@ import type {
 } from '~/operations.ts';
 import type { PgColumn } from '~/pg-core/columns/index.ts';
 import type { PgTable, PgTableWithColumns } from '~/pg-core/table.ts';
-import type { PgViewBase, PgViewWithSelection } from '~/pg-core/view.ts';
+import type { PgViewBase } from '~/pg-core/view-base.ts';
+import type { PgViewWithSelection } from '~/pg-core/view.ts';
 import type {
 	AppendToNullabilityMap,
 	AppendToResult,
@@ -17,11 +18,10 @@ import type {
 	SelectMode,
 	SelectResult,
 } from '~/query-builders/select.types.ts';
-import type { Placeholder, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { ColumnsSelection, Placeholder, SQL, SQLWrapper, View } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import type { Assume, ValueOrArray } from '~/utils.ts';
-import type { ColumnsSelection, View } from '~/view.ts';
 import type { PreparedQuery, PreparedQueryConfig } from '../session.ts';
 import type { PgSelectBase, PgSelectQueryBuilderBase } from './select.ts';
 
diff --git a/drizzle-orm/src/pg-core/query-builders/update.ts b/drizzle-orm/src/pg-core/query-builders/update.ts
index 6b7b24d92..449f99149 100644
--- a/drizzle-orm/src/pg-core/query-builders/update.ts
+++ b/drizzle-orm/src/pg-core/query-builders/update.ts
@@ -11,7 +11,7 @@ import type {
 import type { PgTable } from '~/pg-core/table.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import { Table } from '~/table.ts';
 import { mapUpdateSet, orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import type { SelectedFields, SelectedFieldsOrdered } from './select.types.ts';
diff --git a/drizzle-orm/src/pg-core/subquery.ts b/drizzle-orm/src/pg-core/subquery.ts
index fefb08cac..02d78dee1 100644
--- a/drizzle-orm/src/pg-core/subquery.ts
+++ b/drizzle-orm/src/pg-core/subquery.ts
@@ -1,6 +1,6 @@
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
 import type { Subquery, WithSubquery } from '~/subquery.ts';
-import type { ColumnsSelection } from '~/view.ts';
 
 export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
 	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'pg'>>
diff --git a/drizzle-orm/src/pg-core/view-base.ts b/drizzle-orm/src/pg-core/view-base.ts
new file mode 100644
index 000000000..87f76ac24
--- /dev/null
+++ b/drizzle-orm/src/pg-core/view-base.ts
@@ -0,0 +1,14 @@
+import { entityKind } from '~/entity.ts';
+import { type ColumnsSelection, View } from '~/sql/sql.ts';
+
+export abstract class PgViewBase<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelectedFields extends ColumnsSelection = ColumnsSelection,
+> extends View<TName, TExisting, TSelectedFields> {
+	static readonly [entityKind]: string = 'PgViewBase';
+
+	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
+		readonly viewBrand: 'PgViewBase';
+	};
+}
diff --git a/drizzle-orm/src/pg-core/view.ts b/drizzle-orm/src/pg-core/view.ts
index 4e4eed3ce..99a06036d 100644
--- a/drizzle-orm/src/pg-core/view.ts
+++ b/drizzle-orm/src/pg-core/view.ts
@@ -2,15 +2,15 @@ import type { BuildColumns } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
-import type { SQL } from '~/sql/index.ts';
-import { SelectionProxyHandler } from '~/subquery.ts';
+import type { SQL, ColumnsSelection } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
-import { type ColumnsSelection, View } from '~/view.ts';
 import type { PgColumn, PgColumnBuilderBase } from './columns/common.ts';
-import { QueryBuilder } from './query-builders/index.ts';
+import { QueryBuilder } from './query-builders/query-builder.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { pgTable } from './table.ts';
 import { PgViewConfig } from './view-common.ts';
+import { PgViewBase } from './view-base.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export interface ViewWithConfig {
 	checkOption: 'local' | 'cascaded';
@@ -271,18 +271,6 @@ export class ManualMaterializedViewBuilder<
 	}
 }
 
-export abstract class PgViewBase<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> extends View<TName, TExisting, TSelectedFields> {
-	static readonly [entityKind]: string = 'PgViewBase';
-
-	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
-		readonly viewBrand: 'PgViewBase';
-	};
-}
-
 export class PgView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
diff --git a/drizzle-orm/src/pg-proxy/migrator.ts b/drizzle-orm/src/pg-proxy/migrator.ts
index 70b8c8615..f1b3fb107 100644
--- a/drizzle-orm/src/pg-proxy/migrator.ts
+++ b/drizzle-orm/src/pg-proxy/migrator.ts
@@ -1,6 +1,6 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { PgRemoteDatabase } from './driver.ts';
 
 export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
diff --git a/drizzle-orm/src/pg-proxy/session.ts b/drizzle-orm/src/pg-proxy/session.ts
index 444decb6b..cdff2beca 100644
--- a/drizzle-orm/src/pg-proxy/session.ts
+++ b/drizzle-orm/src/pg-proxy/session.ts
@@ -7,7 +7,7 @@ import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.type
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery as PreparedQueryBase } from '~/pg-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query } from '~/sql/index.ts';
+import { fillPlaceholders, type Query } from '~/sql/sql.ts';
 import { tracer } from '~/tracing.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 import type { RemoteCallback } from './driver.ts';
diff --git a/drizzle-orm/src/planetscale-serverless/session.ts b/drizzle-orm/src/planetscale-serverless/session.ts
index 2f235af41..913008c95 100644
--- a/drizzle-orm/src/planetscale-serverless/session.ts
+++ b/drizzle-orm/src/planetscale-serverless/session.ts
@@ -13,7 +13,7 @@ import {
 	type QueryResultHKT,
 } from '~/mysql-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, type SQL, sql } from '~/sql/sql.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
 export type PlanetScaleConnection = Connection;
diff --git a/drizzle-orm/src/postgres-js/session.ts b/drizzle-orm/src/postgres-js/session.ts
index a430f2415..f861b260f 100644
--- a/drizzle-orm/src/postgres-js/session.ts
+++ b/drizzle-orm/src/postgres-js/session.ts
@@ -8,7 +8,7 @@ import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.type
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query } from '~/sql/index.ts';
+import { fillPlaceholders, type Query } from '~/sql/sql.ts';
 import { tracer } from '~/tracing.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
diff --git a/drizzle-orm/src/query-builders/select.types.ts b/drizzle-orm/src/query-builders/select.types.ts
index 2477ba0ba..9cda2ab8d 100644
--- a/drizzle-orm/src/query-builders/select.types.ts
+++ b/drizzle-orm/src/query-builders/select.types.ts
@@ -1,11 +1,10 @@
 import type { ChangeColumnTableName, Dialect } from '~/column-builder.ts';
 import type { AnyColumn, Column, GetColumnData, UpdateColConfig } from '~/column.ts';
 import type { SelectedFields } from '~/operations.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { ColumnsSelection, SQL, View } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table } from '~/table.ts';
 import type { Assume, DrizzleTypeError, Equal, IsAny, Simplify } from '~/utils.ts';
-import type { ColumnsSelection, View } from '~/view.ts';
 
 export type JoinType = 'inner' | 'left' | 'right' | 'full';
 
diff --git a/drizzle-orm/src/relations.ts b/drizzle-orm/src/relations.ts
index 5bd0d6398..b4750f794 100644
--- a/drizzle-orm/src/relations.ts
+++ b/drizzle-orm/src/relations.ts
@@ -1,7 +1,7 @@
 import { type AnyTable, type InferModelFromColumns, isTable, Table } from '~/table.ts';
 import { type AnyColumn, Column } from './column.ts';
 import { entityKind, is } from './entity.ts';
-import { PrimaryKeyBuilder } from './pg-core/index.ts';
+import { PrimaryKeyBuilder } from './pg-core/primary-keys.ts';
 import {
 	and,
 	asc,
@@ -26,10 +26,8 @@ import {
 	notInArray,
 	notLike,
 	or,
-	type Placeholder,
-	SQL,
-	sql,
-} from './sql/index.ts';
+} from './sql/expressions/index.ts';
+import { type Placeholder, SQL, sql } from './sql/sql.ts';
 import type { Assume, ColumnsWithTable, Equal, Simplify, ValueOrArray } from './utils.ts';
 
 export abstract class Relation<TTableName extends string = string> {
diff --git a/drizzle-orm/src/selection-proxy.ts b/drizzle-orm/src/selection-proxy.ts
new file mode 100644
index 000000000..9127793ac
--- /dev/null
+++ b/drizzle-orm/src/selection-proxy.ts
@@ -0,0 +1,121 @@
+import { ColumnAliasProxyHandler, TableAliasProxyHandler } from './alias.ts';
+import { Column } from './column.ts';
+import { entityKind, is } from './entity.ts';
+import { SQL, View } from './sql/sql.ts';
+import { Subquery, SubqueryConfig } from './subquery.ts';
+import { ViewBaseConfig } from './view-common.ts';
+
+export class SelectionProxyHandler<T extends Subquery | Record<string, unknown> | View>
+	implements ProxyHandler<Subquery | Record<string, unknown> | View>
+{
+	static readonly [entityKind]: string = 'SelectionProxyHandler';
+
+	private config: {
+		/**
+		 * Table alias for the columns
+		 */
+		alias?: string;
+		/**
+		 * What to do when a field is an instance of `SQL.Aliased` and it's not a selection field (from a subquery)
+		 *
+		 * `sql` - return the underlying SQL expression
+		 *
+		 * `alias` - return the field alias
+		 */
+		sqlAliasedBehavior: 'sql' | 'alias';
+		/**
+		 * What to do when a field is an instance of `SQL` and it doesn't have an alias declared
+		 *
+		 * `sql` - return the underlying SQL expression
+		 *
+		 * `error` - return a DrizzleTypeError on type level and throw an error on runtime
+		 */
+		sqlBehavior: 'sql' | 'error';
+
+		/**
+		 * Whether to replace the original name of the column with the alias
+		 * Should be set to `true` for views creation
+		 * @default false
+		 */
+		replaceOriginalName?: boolean;
+	};
+
+	constructor(config: SelectionProxyHandler<T>['config']) {
+		this.config = { ...config };
+	}
+
+	get(subquery: T, prop: string | symbol): any {
+		if (prop === SubqueryConfig) {
+			return {
+				...subquery[SubqueryConfig as keyof typeof subquery],
+				selection: new Proxy(
+					(subquery as Subquery)[SubqueryConfig].selection,
+					this as ProxyHandler<Record<string, unknown>>,
+				),
+			};
+		}
+
+		if (prop === ViewBaseConfig) {
+			return {
+				...subquery[ViewBaseConfig as keyof typeof subquery],
+				selectedFields: new Proxy(
+					(subquery as View)[ViewBaseConfig].selectedFields,
+					this as ProxyHandler<Record<string, unknown>>,
+				),
+			};
+		}
+
+		if (typeof prop === 'symbol') {
+			return subquery[prop as keyof typeof subquery];
+		}
+
+		const columns = is(subquery, Subquery)
+			? subquery[SubqueryConfig].selection
+			: is(subquery, View)
+			? subquery[ViewBaseConfig].selectedFields
+			: subquery;
+		const value: unknown = columns[prop as keyof typeof columns];
+
+		if (is(value, SQL.Aliased)) {
+			// Never return the underlying SQL expression for a field previously selected in a subquery
+			if (this.config.sqlAliasedBehavior === 'sql' && !value.isSelectionField) {
+				return value.sql;
+			}
+
+			const newValue = value.clone();
+			newValue.isSelectionField = true;
+			return newValue;
+		}
+
+		if (is(value, SQL)) {
+			if (this.config.sqlBehavior === 'sql') {
+				return value;
+			}
+
+			throw new Error(
+				`You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`,
+			);
+		}
+
+		if (is(value, Column)) {
+			if (this.config.alias) {
+				return new Proxy(
+					value,
+					new ColumnAliasProxyHandler(
+						new Proxy(
+							value.table,
+							new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false),
+						),
+					),
+				);
+			}
+			return value;
+		}
+
+		if (typeof value !== 'object' || value === null) {
+			return value;
+		}
+
+		return new Proxy(value, new SelectionProxyHandler(this.config));
+	}
+}
diff --git a/drizzle-orm/src/sql-js/session.ts b/drizzle-orm/src/sql-js/session.ts
index 24d173857..978de6e3e 100644
--- a/drizzle-orm/src/sql-js/session.ts
+++ b/drizzle-orm/src/sql-js/session.ts
@@ -3,7 +3,7 @@ import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import type { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
diff --git a/drizzle-orm/src/sql/expressions/conditions.ts b/drizzle-orm/src/sql/expressions/conditions.ts
index 3a2f78bfd..d1fa377ce 100644
--- a/drizzle-orm/src/sql/expressions/conditions.ts
+++ b/drizzle-orm/src/sql/expressions/conditions.ts
@@ -1,7 +1,6 @@
 import { type AnyColumn, Column, type GetColumnData } from '~/column.ts';
 import { is } from '~/entity.ts';
 import { Table } from '~/table.ts';
-import { View } from '~/view.ts';
 import {
 	isDriverValueEncoder,
 	isSQLWrapper,
@@ -12,6 +11,7 @@ import {
 	type SQLChunk,
 	type SQLWrapper,
 	StringChunk,
+	View,
 } from '../sql.ts';
 
 export function bindIfParam(value: unknown, column: SQLWrapper): SQLChunk {
diff --git a/drizzle-orm/src/sql/sql.ts b/drizzle-orm/src/sql/sql.ts
index b4ec5fca2..a40eb079d 100644
--- a/drizzle-orm/src/sql/sql.ts
+++ b/drizzle-orm/src/sql/sql.ts
@@ -3,10 +3,10 @@ import { Relation } from '~/relations.ts';
 import { Subquery, SubqueryConfig } from '~/subquery.ts';
 import { tracer } from '~/tracing.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import { View } from '~/view.ts';
 import type { AnyColumn } from '../column.ts';
 import { Column } from '../column.ts';
 import { Table } from '../table.ts';
+import type { SelectedFields } from '~/operations.ts';
 
 /**
  * This class is used to indicate a primitive param value that is used in `sql` tag.
@@ -578,6 +578,58 @@ export function fillPlaceholders(params: unknown[], values: Record<string, unkno
 	});
 }
 
+export type ColumnsSelection = Record<string, unknown>;
+
+export abstract class View<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+> implements SQLWrapper {
+	static readonly [entityKind]: string = 'View';
+
+	declare _: {
+		brand: 'View';
+		viewBrand: string;
+		name: TName;
+		existing: TExisting;
+		selectedFields: TSelection;
+	};
+
+	/** @internal */
+	[ViewBaseConfig]: {
+		name: TName;
+		originalName: TName;
+		schema: string | undefined;
+		selectedFields: SelectedFields<AnyColumn, Table>;
+		isExisting: TExisting;
+		query: TExisting extends true ? undefined : SQL;
+		isAlias: boolean;
+	};
+
+	constructor(
+		{ name, schema, selectedFields, query }: {
+			name: TName;
+			schema: string | undefined;
+			selectedFields: SelectedFields<AnyColumn, Table>;
+			query: SQL | undefined;
+		},
+	) {
+		this[ViewBaseConfig] = {
+			name,
+			originalName: name,
+			schema,
+			selectedFields,
+			query: query as (TExisting extends true ? undefined : SQL),
+			isExisting: !query as TExisting,
+			isAlias: false,
+		};
+	}
+
+	getSQL(): SQL<unknown> {
+		return new SQL([this]);
+	}
+}
+
 // Defined separately from the Column class to resolve circular dependency
 Column.prototype.getSQL = function() {
 	return new SQL([this]);
@@ -587,3 +639,8 @@ Column.prototype.getSQL = function() {
 Table.prototype.getSQL = function() {
 	return new SQL([this]);
 };
+
+// Defined separately from the Column class to resolve circular dependency
+Subquery.prototype.getSQL = function() {
+	return new SQL([this]);
+};
\ No newline at end of file
diff --git a/drizzle-orm/src/sqlite-core/alias.ts b/drizzle-orm/src/sqlite-core/alias.ts
index bb873baa9..caf7ac9bb 100644
--- a/drizzle-orm/src/sqlite-core/alias.ts
+++ b/drizzle-orm/src/sqlite-core/alias.ts
@@ -2,7 +2,7 @@ import { TableAliasProxyHandler } from '~/alias.ts';
 import type { BuildAliasTable } from './query-builders/select.types.ts';
 
 import type { SQLiteTable } from './table.ts';
-import type { SQLiteViewBase } from './view.ts';
+import type { SQLiteViewBase } from './view-base.ts';
 
 export function alias<TTable extends SQLiteTable | SQLiteViewBase, TAlias extends string>(
 	table: TTable,
diff --git a/drizzle-orm/src/sqlite-core/checks.ts b/drizzle-orm/src/sqlite-core/checks.ts
index df992f7c5..8204a54f0 100644
--- a/drizzle-orm/src/sqlite-core/checks.ts
+++ b/drizzle-orm/src/sqlite-core/checks.ts
@@ -1,5 +1,5 @@
 import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 import type { SQLiteTable } from './table.ts';
 
 export class CheckBuilder {
diff --git a/drizzle-orm/src/sqlite-core/columns/custom.ts b/drizzle-orm/src/sqlite-core/columns/custom.ts
index 5e0ff5732..e8b765ffc 100644
--- a/drizzle-orm/src/sqlite-core/columns/custom.ts
+++ b/drizzle-orm/src/sqlite-core/columns/custom.ts
@@ -1,7 +1,7 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 import type { AnySQLiteTable } from '~/sqlite-core/table.ts';
 import type { Equal } from '~/utils.ts';
 import { SQLiteColumn, SQLiteColumnBuilder } from './common.ts';
diff --git a/drizzle-orm/src/sqlite-core/columns/integer.ts b/drizzle-orm/src/sqlite-core/columns/integer.ts
index 86db7b08a..77f64069c 100644
--- a/drizzle-orm/src/sqlite-core/columns/integer.ts
+++ b/drizzle-orm/src/sqlite-core/columns/integer.ts
@@ -8,7 +8,7 @@ import type {
 } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { OnConflict } from '~/sqlite-core/utils.ts';
 import type { Equal, Or } from '~/utils.ts';
 import type { AnySQLiteTable } from '../table.ts';
diff --git a/drizzle-orm/src/sqlite-core/db.ts b/drizzle-orm/src/sqlite-core/db.ts
index 2f36a4d43..18594a3ba 100644
--- a/drizzle-orm/src/sqlite-core/db.ts
+++ b/drizzle-orm/src/sqlite-core/db.ts
@@ -1,7 +1,7 @@
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import type { SQLWrapper } from '~/sql/index.ts';
+import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
 import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import {
 	QueryBuilder,
@@ -18,13 +18,13 @@ import type {
 	SQLiteTransactionConfig,
 } from '~/sqlite-core/session.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
-import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
+import { WithSubquery } from '~/subquery.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
-import type { ColumnsSelection } from '~/view.ts';
 import { RelationalQueryBuilder } from './query-builders/query.ts';
 import { SQLiteRaw } from './query-builders/raw.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import type { WithSubqueryWithSelection } from './subquery.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export class BaseSQLiteDatabase<
 	TResultKind extends 'sync' | 'async',
diff --git a/drizzle-orm/src/sqlite-core/dialect.ts b/drizzle-orm/src/sqlite-core/dialect.ts
index c6e64da60..14b99b6ad 100644
--- a/drizzle-orm/src/sqlite-core/dialect.ts
+++ b/drizzle-orm/src/sqlite-core/dialect.ts
@@ -16,7 +16,8 @@ import {
 	type TableRelationalConfig,
 	type TablesRelationalConfig,
 } from '~/relations.ts';
-import { and, eq, Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/index.ts';
+import { Param, type QueryWithTypings, SQL, sql, type SQLChunk } from '~/sql/sql.ts';
+import { and, eq } from '~/sql/index.ts'
 import { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 import type { SQLiteDeleteConfig, SQLiteInsertConfig, SQLiteUpdateConfig } from '~/sqlite-core/query-builders/index.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
@@ -30,7 +31,7 @@ import type {
 	SQLiteSelectJoinConfig,
 } from './query-builders/select.types.ts';
 import type { SQLiteSession } from './session.ts';
-import { SQLiteViewBase } from './view.ts';
+import { SQLiteViewBase } from './view-base.ts';
 
 export abstract class SQLiteDialect {
 	static readonly [entityKind]: string = 'SQLiteDialect';
diff --git a/drizzle-orm/src/sqlite-core/expressions.ts b/drizzle-orm/src/sqlite-core/expressions.ts
index 5153c2bfa..c04db49d1 100644
--- a/drizzle-orm/src/sqlite-core/expressions.ts
+++ b/drizzle-orm/src/sqlite-core/expressions.ts
@@ -1,6 +1,6 @@
 import { bindIfParam } from '~/expressions.ts';
-import type { SQL, SQLChunk, SQLWrapper } from '~/sql/index.ts';
-import { sql } from '~/sql/index.ts';
+import type { SQL, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
+import { sql } from '~/sql/sql.ts';
 import type { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 
 export * from '~/expressions.ts';
diff --git a/drizzle-orm/src/sqlite-core/indexes.ts b/drizzle-orm/src/sqlite-core/indexes.ts
index 8bb004940..70ca62a8c 100644
--- a/drizzle-orm/src/sqlite-core/indexes.ts
+++ b/drizzle-orm/src/sqlite-core/indexes.ts
@@ -1,5 +1,5 @@
 import { entityKind } from '~/entity.ts';
-import type { SQL } from '~/sql/index.ts';
+import type { SQL } from '~/sql/sql.ts';
 import type { SQLiteColumn } from './columns/index.ts';
 import type { SQLiteTable } from './table.ts';
 
diff --git a/drizzle-orm/src/sqlite-core/query-builders/delete.ts b/drizzle-orm/src/sqlite-core/query-builders/delete.ts
index 746bb28fb..2296310f5 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/delete.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/delete.ts
@@ -2,7 +2,7 @@ import { entityKind } from '~/entity.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
diff --git a/drizzle-orm/src/sqlite-core/query-builders/insert.ts b/drizzle-orm/src/sqlite-core/query-builders/insert.ts
index 669ee5ac5..1190fe79e 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/insert.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/insert.ts
@@ -2,8 +2,8 @@ import { entityKind, is } from '~/entity.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Placeholder, Query, SQLWrapper } from '~/sql/index.ts';
-import { Param, SQL, sql } from '~/sql/index.ts';
+import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
+import { Param, SQL, sql } from '~/sql/sql.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { IndexColumn } from '~/sqlite-core/indexes.ts';
 import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
diff --git a/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts b/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
index 1e30669bd..54b615b4d 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/query-builder.ts
@@ -2,10 +2,11 @@ import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import { SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import type { WithSubqueryWithSelection } from '~/sqlite-core/subquery.ts';
-import { SelectionProxyHandler, WithSubquery } from '~/subquery.ts';
-import type { ColumnsSelection } from '~/view.ts';
 import { SQLiteSelectBuilder } from './select.ts';
 import type { SelectedFields } from './select.types.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
+import { WithSubquery } from '~/subquery.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export class QueryBuilder {
 	static readonly [entityKind]: string = 'SQLiteQueryBuilder';
diff --git a/drizzle-orm/src/sqlite-core/query-builders/query.ts b/drizzle-orm/src/sqlite-core/query-builders/query.ts
index b301acdb2..a8f04b764 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/query.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/query.ts
@@ -9,7 +9,7 @@ import {
 	type TablesRelationalConfig,
 } from '~/relations.ts';
 import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, QueryWithTypings, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { Query, QueryWithTypings, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { KnownKeysOnly } from '~/utils.ts';
 import type { SQLiteDialect } from '../dialect.ts';
 import type { PreparedQueryConfig, SQLitePreparedQuery, SQLiteSession } from '../session.ts';
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.ts b/drizzle-orm/src/sqlite-core/query-builders/select.ts
index a8e0f72bf..02f30316c 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.ts
@@ -11,18 +11,16 @@ import type {
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { RunnableQuery } from '~/runnable-query.ts';
-import { type Placeholder, type Query, SQL } from '~/sql/index.ts';
+import { SQL, View } from '~/sql/sql.ts';
+import type { ColumnsSelection, Placeholder, Query } from '~/sql/sql.ts';
 import type { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { SQLiteSession } from '~/sqlite-core/session.ts';
 import type { SubqueryWithSelection } from '~/sqlite-core/subquery.ts';
 import type { SQLiteTable } from '~/sqlite-core/table.ts';
-import { SelectionProxyHandler, Subquery, SubqueryConfig } from '~/subquery.ts';
 import { Table } from '~/table.ts';
 import { applyMixins, getTableColumns, getTableLikeName, orderSelectedFields, type ValueOrArray } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import { type ColumnsSelection, View } from '~/view.ts';
-import { SQLiteViewBase } from '../view.ts';
 import type {
 	CreateSQLiteSelectFromBuilderMode,
 	SelectedFields,
@@ -35,6 +33,9 @@ import type {
 	SQLiteSelectPrepare,
 	SQLiteSelectWithout,
 } from './select.types.ts';
+import { Subquery, SubqueryConfig } from '~/subquery.ts';
+import { SQLiteViewBase } from '../view-base.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export class SQLiteSelectBuilder<
 	TSelection extends SelectedFields | undefined,
diff --git a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
index d2cb53df8..8e51819d4 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/select.types.ts
@@ -1,4 +1,4 @@
-import type { Placeholder, SQL } from '~/sql/index.ts';
+import type { ColumnsSelection, Placeholder, SQL, View } from '~/sql/sql.ts';
 import type { Assume } from '~/utils.ts';
 
 import type { SQLiteColumn } from '~/sqlite-core/columns/index.ts';
@@ -22,10 +22,10 @@ import type {
 } from '~/query-builders/select.types.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
-import type { ColumnsSelection, View } from '~/view.ts';
 import type { SQLitePreparedQuery } from '../session.ts';
-import type { SQLiteViewBase, SQLiteViewWithSelection } from '../view.ts';
 import type { SQLiteSelectBase, SQLiteSelectQueryBuilderBase } from './select.ts';
+import type { SQLiteViewBase } from '../view-base.ts';
+import type { SQLiteViewWithSelection } from '../view.ts';
 
 export interface SQLiteSelectJoinConfig {
 	on: SQL | undefined;
diff --git a/drizzle-orm/src/sqlite-core/query-builders/update.ts b/drizzle-orm/src/sqlite-core/query-builders/update.ts
index aaafada7e..857a944d8 100644
--- a/drizzle-orm/src/sqlite-core/query-builders/update.ts
+++ b/drizzle-orm/src/sqlite-core/query-builders/update.ts
@@ -3,7 +3,7 @@ import { entityKind } from '~/entity.ts';
 import type { SelectResultFields } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import type { RunnableQuery } from '~/runnable-query.ts';
-import type { Query, SQL, SQLWrapper } from '~/sql/index.ts';
+import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { SQLiteDialect } from '~/sqlite-core/dialect.ts';
 import type { SQLitePreparedQuery, SQLiteSession } from '~/sqlite-core/session.ts';
 import { SQLiteTable } from '~/sqlite-core/table.ts';
diff --git a/drizzle-orm/src/sqlite-core/session.ts b/drizzle-orm/src/sqlite-core/session.ts
index d4afb4f9d..0dcfebe38 100644
--- a/drizzle-orm/src/sqlite-core/session.ts
+++ b/drizzle-orm/src/sqlite-core/session.ts
@@ -2,7 +2,7 @@ import { entityKind } from '~/entity.ts';
 import { DrizzleError, TransactionRollbackError } from '~/errors.ts';
 import type { TablesRelationalConfig } from '~/relations.ts';
 import type { PreparedQuery } from '~/session.ts';
-import type { Query, SQL } from '~/sql/index.ts';
+import type { Query, SQL } from '~/sql/sql.ts';
 import type { SQLiteAsyncDialect, SQLiteSyncDialect } from '~/sqlite-core/dialect.ts';
 import { QueryPromise } from '../index.ts';
 import { BaseSQLiteDatabase } from './db.ts';
diff --git a/drizzle-orm/src/sqlite-core/subquery.ts b/drizzle-orm/src/sqlite-core/subquery.ts
index be16261a6..587f53e7d 100644
--- a/drizzle-orm/src/sqlite-core/subquery.ts
+++ b/drizzle-orm/src/sqlite-core/subquery.ts
@@ -1,6 +1,6 @@
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import type { Subquery, WithSubquery } from '~/subquery.ts';
-import type { ColumnsSelection } from '~/view.ts';
+import type { ColumnsSelection } from '~/sql/sql.ts';
 
 export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> =
 	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'sqlite'>>
diff --git a/drizzle-orm/src/sqlite-core/view-base.ts b/drizzle-orm/src/sqlite-core/view-base.ts
new file mode 100644
index 000000000..64f6529d4
--- /dev/null
+++ b/drizzle-orm/src/sqlite-core/view-base.ts
@@ -0,0 +1,15 @@
+import { entityKind } from '~/entity.ts';
+import type { ColumnsSelection} from '~/sql/sql.ts';
+import { View } from '~/sql/sql.ts';
+
+export abstract class SQLiteViewBase<
+	TName extends string = string,
+	TExisting extends boolean = boolean,
+	TSelection extends ColumnsSelection = ColumnsSelection,
+> extends View<TName, TExisting, TSelection> {
+	static readonly [entityKind]: string = 'SQLiteViewBase';
+
+	declare _: View<TName, TExisting, TSelection>['_'] & {
+		viewBrand: 'SQLiteView';
+	};
+}
diff --git a/drizzle-orm/src/sqlite-core/view.ts b/drizzle-orm/src/sqlite-core/view.ts
index 2a51c2ffa..d07a36ba7 100644
--- a/drizzle-orm/src/sqlite-core/view.ts
+++ b/drizzle-orm/src/sqlite-core/view.ts
@@ -2,15 +2,15 @@ import type { BuildColumns } from '~/column-builder.ts';
 import { entityKind } from '~/entity.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
-import type { SQL } from '~/sql/index.ts';
-import { SelectionProxyHandler } from '~/subquery.ts';
+import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
-import { type ColumnsSelection, View } from '~/view.ts';
 import type { SQLiteColumn, SQLiteColumnBuilderBase } from './columns/common.ts';
 import { QueryBuilder } from './query-builders/query-builder.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import { sqliteTable } from './table.ts';
 import { SQLiteViewConfig } from './view-common.ts';
+import { SQLiteViewBase } from './view-base.ts';
+import { SelectionProxyHandler } from '~/selection-proxy.ts';
 
 export interface ViewBuilderConfig {
 	algorithm?: 'undefined' | 'merge' | 'temptable';
@@ -127,18 +127,6 @@ export class ManualViewBuilder<
 	}
 }
 
-export abstract class SQLiteViewBase<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelection extends ColumnsSelection = ColumnsSelection,
-> extends View<TName, TExisting, TSelection> {
-	static readonly [entityKind]: string = 'SQLiteViewBase';
-
-	declare _: View<TName, TExisting, TSelection>['_'] & {
-		viewBrand: 'SQLiteView';
-	};
-}
-
 export class SQLiteView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
diff --git a/drizzle-orm/src/sqlite-proxy/migrator.ts b/drizzle-orm/src/sqlite-proxy/migrator.ts
index c5822a8c8..29448e01a 100644
--- a/drizzle-orm/src/sqlite-proxy/migrator.ts
+++ b/drizzle-orm/src/sqlite-proxy/migrator.ts
@@ -1,6 +1,6 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { SqliteRemoteDatabase } from './driver.ts';
 
 export type ProxyMigrator = (migrationQueries: string[]) => Promise<void>;
diff --git a/drizzle-orm/src/sqlite-proxy/session.ts b/drizzle-orm/src/sqlite-proxy/session.ts
index b27c6c492..c8f35050c 100644
--- a/drizzle-orm/src/sqlite-proxy/session.ts
+++ b/drizzle-orm/src/sqlite-proxy/session.ts
@@ -2,7 +2,7 @@ import { entityKind } from '~/entity.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import type { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
 import { SQLiteTransaction } from '~/sqlite-core/index.ts';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types.ts';
diff --git a/drizzle-orm/src/subquery.ts b/drizzle-orm/src/subquery.ts
index 8e1413528..2f292cf06 100644
--- a/drizzle-orm/src/subquery.ts
+++ b/drizzle-orm/src/subquery.ts
@@ -1,12 +1,12 @@
-import { ColumnAliasProxyHandler, TableAliasProxyHandler } from './alias.ts';
-import { Column } from './column.ts';
-import { entityKind, is } from './entity.ts';
-import { SQL, type SQLWrapper } from './sql/index.ts';
-import { ViewBaseConfig } from './view-common.ts';
-import { type ColumnsSelection, View } from './view.ts';
+import { entityKind } from './entity.ts';
+import type { SQL, SQLWrapper, ColumnsSelection } from './sql/sql.ts';
 
 export const SubqueryConfig = Symbol.for('drizzle:SubqueryConfig');
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface Subquery<TAlias extends string = string, TSelectedFields = unknown> extends SQLWrapper {
+	// SQLWrapper runtime implementation is defined in 'sql/sql.ts'
+}
 export class Subquery<TAlias extends string = string, TSelectedFields = unknown> implements SQLWrapper {
 	static readonly [entityKind]: string = 'Subquery';
 
@@ -33,126 +33,11 @@ export class Subquery<TAlias extends string = string, TSelectedFields = unknown>
 		};
 	}
 
-	getSQL(): SQL<unknown> {
-		return new SQL([this]);
-	}
+	// getSQL(): SQL<unknown> {
+	// 	return new SQL([this]);
+	// }
 }
 
 export class WithSubquery<TAlias extends string = string, TSelection = unknown> extends Subquery<TAlias, TSelection> {
 	static readonly [entityKind]: string = 'WithSubquery';
-}
-
-export class SelectionProxyHandler<T extends Subquery | Record<string, unknown> | View>
-	implements ProxyHandler<Subquery | Record<string, unknown> | View>
-{
-	static readonly [entityKind]: string = 'SelectionProxyHandler';
-
-	private config: {
-		/**
-		 * Table alias for the columns
-		 */
-		alias?: string;
-		/**
-		 * What to do when a field is an instance of `SQL.Aliased` and it's not a selection field (from a subquery)
-		 *
-		 * `sql` - return the underlying SQL expression
-		 *
-		 * `alias` - return the field alias
-		 */
-		sqlAliasedBehavior: 'sql' | 'alias';
-		/**
-		 * What to do when a field is an instance of `SQL` and it doesn't have an alias declared
-		 *
-		 * `sql` - return the underlying SQL expression
-		 *
-		 * `error` - return a DrizzleTypeError on type level and throw an error on runtime
-		 */
-		sqlBehavior: 'sql' | 'error';
-
-		/**
-		 * Whether to replace the original name of the column with the alias
-		 * Should be set to `true` for views creation
-		 * @default false
-		 */
-		replaceOriginalName?: boolean;
-	};
-
-	constructor(config: SelectionProxyHandler<T>['config']) {
-		this.config = { ...config };
-	}
-
-	get(subquery: T, prop: string | symbol): any {
-		if (prop === SubqueryConfig) {
-			return {
-				...subquery[SubqueryConfig as keyof typeof subquery],
-				selection: new Proxy(
-					(subquery as Subquery)[SubqueryConfig].selection,
-					this as ProxyHandler<Record<string, unknown>>,
-				),
-			};
-		}
-
-		if (prop === ViewBaseConfig) {
-			return {
-				...subquery[ViewBaseConfig as keyof typeof subquery],
-				selectedFields: new Proxy(
-					(subquery as View)[ViewBaseConfig].selectedFields,
-					this as ProxyHandler<Record<string, unknown>>,
-				),
-			};
-		}
-
-		if (typeof prop === 'symbol') {
-			return subquery[prop as keyof typeof subquery];
-		}
-
-		const columns = is(subquery, Subquery)
-			? subquery[SubqueryConfig].selection
-			: is(subquery, View)
-			? subquery[ViewBaseConfig].selectedFields
-			: subquery;
-		const value: unknown = columns[prop as keyof typeof columns];
-
-		if (is(value, SQL.Aliased)) {
-			// Never return the underlying SQL expression for a field previously selected in a subquery
-			if (this.config.sqlAliasedBehavior === 'sql' && !value.isSelectionField) {
-				return value.sql;
-			}
-
-			const newValue = value.clone();
-			newValue.isSelectionField = true;
-			return newValue;
-		}
-
-		if (is(value, SQL)) {
-			if (this.config.sqlBehavior === 'sql') {
-				return value;
-			}
-
-			throw new Error(
-				`You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`,
-			);
-		}
-
-		if (is(value, Column)) {
-			if (this.config.alias) {
-				return new Proxy(
-					value,
-					new ColumnAliasProxyHandler(
-						new Proxy(
-							value.table,
-							new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false),
-						),
-					),
-				);
-			}
-			return value;
-		}
-
-		if (typeof value !== 'object' || value === null) {
-			return value;
-		}
-
-		return new Proxy(value, new SelectionProxyHandler(this.config));
-	}
-}
+}
\ No newline at end of file
diff --git a/drizzle-orm/src/tracing-utils.ts b/drizzle-orm/src/tracing-utils.ts
new file mode 100644
index 000000000..b4809af25
--- /dev/null
+++ b/drizzle-orm/src/tracing-utils.ts
@@ -0,0 +1,3 @@
+export function iife<T extends unknown[], U>(fn: (...args: T) => U, ...args: T): U {
+	return fn(...args);
+}
\ No newline at end of file
diff --git a/drizzle-orm/src/tracing.ts b/drizzle-orm/src/tracing.ts
index d18c2832e..7d5fd165b 100644
--- a/drizzle-orm/src/tracing.ts
+++ b/drizzle-orm/src/tracing.ts
@@ -1,5 +1,5 @@
 import type { Span, Tracer } from '@opentelemetry/api';
-import { iife } from '~/utils.ts';
+import { iife } from '~/tracing-utils.ts';
 import { npmVersion } from '~/version.ts';
 
 let otel: typeof import('@opentelemetry/api') | undefined;
diff --git a/drizzle-orm/src/utils.ts b/drizzle-orm/src/utils.ts
index b92a58465..afb750c9d 100644
--- a/drizzle-orm/src/utils.ts
+++ b/drizzle-orm/src/utils.ts
@@ -4,12 +4,11 @@ import { is } from './entity.ts';
 import type { Logger } from './logger.ts';
 import type { SelectedFieldsOrdered } from './operations.ts';
 import type { TableLike } from './query-builders/select.types.ts';
-import { Param, SQL } from './sql/index.ts';
-import type { DriverValueDecoder } from './sql/index.ts';
+import { Param, SQL, View } from './sql/sql.ts';
+import type { DriverValueDecoder } from './sql/sql.ts';
 import { Subquery, SubqueryConfig } from './subquery.ts';
 import { getTableName, Table } from './table.ts';
 import { ViewBaseConfig } from './view-common.ts';
-import { View } from './view.ts';
 
 /** @internal */
 export function mapResultRow<TResult>(
@@ -199,8 +198,4 @@ export type KnownKeysOnly<T, U> = {
 	[K in keyof T]: K extends keyof U ? T[K] : never;
 };
 
-export function iife<T extends unknown[], U>(fn: (...args: T) => U, ...args: T): U {
-	return fn(...args);
-}
-
 export type IsAny<T> = 0 extends (1 & T) ? true : false;
diff --git a/drizzle-orm/src/vercel-postgres/session.ts b/drizzle-orm/src/vercel-postgres/session.ts
index 2dde91f6d..f85748b46 100644
--- a/drizzle-orm/src/vercel-postgres/session.ts
+++ b/drizzle-orm/src/vercel-postgres/session.ts
@@ -14,7 +14,7 @@ import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.type
 import type { PgTransactionConfig, PreparedQueryConfig, QueryResultHKT } from '~/pg-core/session.ts';
 import { PgSession, PreparedQuery } from '~/pg-core/session.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
-import { fillPlaceholders, type Query, sql } from '~/sql/index.ts';
+import { fillPlaceholders, type Query, sql } from '~/sql/sql.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
 export type VercelPgClient = VercelPool | VercelClient | VercelPoolClient;
diff --git a/drizzle-orm/src/view.ts b/drizzle-orm/src/view.ts
deleted file mode 100644
index bd1485bda..000000000
--- a/drizzle-orm/src/view.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import type { AnyColumn } from './column.ts';
-import { entityKind } from './entity.ts';
-import type { SelectedFields } from './operations.ts';
-import { SQL, type SQLWrapper } from './sql/index.ts';
-import type { Table } from './table.ts';
-import { ViewBaseConfig } from './view-common.ts';
-
-export type ColumnsSelection = Record<string, unknown>;
-
-export abstract class View<
-	TName extends string = string,
-	TExisting extends boolean = boolean,
-	TSelection extends ColumnsSelection = ColumnsSelection,
-> implements SQLWrapper {
-	static readonly [entityKind]: string = 'View';
-
-	declare _: {
-		brand: 'View';
-		viewBrand: string;
-		name: TName;
-		existing: TExisting;
-		selectedFields: TSelection;
-	};
-
-	/** @internal */
-	[ViewBaseConfig]: {
-		name: TName;
-		originalName: TName;
-		schema: string | undefined;
-		selectedFields: SelectedFields<AnyColumn, Table>;
-		isExisting: TExisting;
-		query: TExisting extends true ? undefined : SQL;
-		isAlias: boolean;
-	};
-
-	constructor(
-		{ name, schema, selectedFields, query }: {
-			name: TName;
-			schema: string | undefined;
-			selectedFields: SelectedFields<AnyColumn, Table>;
-			query: SQL | undefined;
-		},
-	) {
-		this[ViewBaseConfig] = {
-			name,
-			originalName: name,
-			schema,
-			selectedFields,
-			query: query as (TExisting extends true ? undefined : SQL),
-			isExisting: !query as TExisting,
-			isAlias: false,
-		};
-	}
-
-	getSQL(): SQL<unknown> {
-		return new SQL([this]);
-	}
-}
diff --git a/drizzle-orm/type-tests/mysql/db-rel.ts b/drizzle-orm/type-tests/mysql/db-rel.ts
index 0d528b186..957e6c9ce 100644
--- a/drizzle-orm/type-tests/mysql/db-rel.ts
+++ b/drizzle-orm/type-tests/mysql/db-rel.ts
@@ -1,7 +1,7 @@
 import pg from 'pg';
 import { type Equal, Expect } from 'type-tests/utils.ts';
 import { drizzle } from '~/node-postgres/index.ts';
-import { placeholder, sql } from '~/sql/index.ts';
+import { placeholder, sql } from '~/sql/sql.ts';
 import * as schema from './tables-rel.ts';
 
 const { Pool } = pg;
diff --git a/drizzle-orm/type-tests/mysql/delete.ts b/drizzle-orm/type-tests/mysql/delete.ts
index 314fd2ed5..c3e5afbb2 100644
--- a/drizzle-orm/type-tests/mysql/delete.ts
+++ b/drizzle-orm/type-tests/mysql/delete.ts
@@ -3,7 +3,7 @@ import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
 import type { MySqlDelete } from '~/mysql-core/index.ts';
 import type { MySqlRawQueryResult } from '~/mysql2/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-orm/type-tests/mysql/insert.ts b/drizzle-orm/type-tests/mysql/insert.ts
index c5d9814ab..edc48d5a2 100644
--- a/drizzle-orm/type-tests/mysql/insert.ts
+++ b/drizzle-orm/type-tests/mysql/insert.ts
@@ -2,7 +2,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { int, type MySqlInsert, mysqlTable, text } from '~/mysql-core/index.ts';
 import type { MySqlRawQueryResult } from '~/mysql2/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-orm/type-tests/mysql/select.ts b/drizzle-orm/type-tests/mysql/select.ts
index fd28ce598..0a6af743b 100644
--- a/drizzle-orm/type-tests/mysql/select.ts
+++ b/drizzle-orm/type-tests/mysql/select.ts
@@ -22,7 +22,7 @@ import {
 	or,
 } from '~/expressions.ts';
 import { alias } from '~/mysql-core/alias.ts';
-import { param, sql } from '~/sql/index.ts';
+import { param, sql } from '~/sql/sql.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
diff --git a/drizzle-orm/type-tests/mysql/subquery.ts b/drizzle-orm/type-tests/mysql/subquery.ts
index 920520e45..a76cd1919 100644
--- a/drizzle-orm/type-tests/mysql/subquery.ts
+++ b/drizzle-orm/type-tests/mysql/subquery.ts
@@ -1,7 +1,7 @@
 import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/expressions.ts';
 import { alias, int, mysqlTable, serial, text } from '~/mysql-core/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { DrizzleTypeError, Equal } from '~/utils.ts';
 import { db } from './db.ts';
 
diff --git a/drizzle-orm/type-tests/mysql/tables.ts b/drizzle-orm/type-tests/mysql/tables.ts
index aad863086..6eac879da 100644
--- a/drizzle-orm/type-tests/mysql/tables.ts
+++ b/drizzle-orm/type-tests/mysql/tables.ts
@@ -27,7 +27,7 @@ import {
 } from '~/mysql-core/index.ts';
 import { mysqlSchema } from '~/mysql-core/schema.ts';
 import { mysqlView, type MySqlViewWithSelection } from '~/mysql-core/view.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 
 export const users = mysqlTable(
diff --git a/drizzle-orm/type-tests/mysql/update.ts b/drizzle-orm/type-tests/mysql/update.ts
index 31139ee7a..dc6967f44 100644
--- a/drizzle-orm/type-tests/mysql/update.ts
+++ b/drizzle-orm/type-tests/mysql/update.ts
@@ -1,7 +1,7 @@
 import { type Equal, Expect } from 'type-tests/utils.ts';
 import type { MySqlUpdate } from '~/mysql-core/index.ts';
 import type { MySqlRawQueryResult } from '~/mysql2/session.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-orm/type-tests/mysql/with.ts b/drizzle-orm/type-tests/mysql/with.ts
index eb36e520f..338f9c43b 100644
--- a/drizzle-orm/type-tests/mysql/with.ts
+++ b/drizzle-orm/type-tests/mysql/with.ts
@@ -2,7 +2,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { gt, inArray } from '~/expressions.ts';
 import { int, mysqlTable, serial, text } from '~/mysql-core/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 
 const orders = mysqlTable('orders', {
diff --git a/drizzle-orm/type-tests/pg/db-rel.ts b/drizzle-orm/type-tests/pg/db-rel.ts
index 3e90fbb8e..c8cc63c7f 100644
--- a/drizzle-orm/type-tests/pg/db-rel.ts
+++ b/drizzle-orm/type-tests/pg/db-rel.ts
@@ -1,7 +1,7 @@
 import pg from 'pg';
 import { type Equal, Expect } from 'type-tests/utils.ts';
 import { drizzle } from '~/node-postgres/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import * as schema from './tables-rel.ts';
 
 const { Pool } = pg;
diff --git a/drizzle-orm/type-tests/pg/delete.ts b/drizzle-orm/type-tests/pg/delete.ts
index 7fd9c3dc6..6421db090 100644
--- a/drizzle-orm/type-tests/pg/delete.ts
+++ b/drizzle-orm/type-tests/pg/delete.ts
@@ -3,7 +3,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
 import type { PgDelete } from '~/pg-core/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-orm/type-tests/pg/insert.ts b/drizzle-orm/type-tests/pg/insert.ts
index 1ea9e8bd4..6a5179804 100644
--- a/drizzle-orm/type-tests/pg/insert.ts
+++ b/drizzle-orm/type-tests/pg/insert.ts
@@ -2,7 +2,7 @@ import type { QueryResult } from 'pg';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import type { PgInsert } from '~/pg-core/query-builders/insert.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-orm/type-tests/pg/other.ts b/drizzle-orm/type-tests/pg/other.ts
index e1e781402..38d41f113 100644
--- a/drizzle-orm/type-tests/pg/other.ts
+++ b/drizzle-orm/type-tests/pg/other.ts
@@ -1,6 +1,6 @@
 import type { QueryResult } from 'pg';
 import { eq, inArray } from '~/expressions.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
diff --git a/drizzle-orm/type-tests/pg/select.ts b/drizzle-orm/type-tests/pg/select.ts
index 9f22782f8..0fde90a71 100644
--- a/drizzle-orm/type-tests/pg/select.ts
+++ b/drizzle-orm/type-tests/pg/select.ts
@@ -37,7 +37,7 @@ import {
 	QueryBuilder,
 	text,
 } from '~/pg-core/index.ts';
-import { type SQL, sql } from '~/sql/index.ts';
+import { type SQL, sql } from '~/sql/sql.ts';
 
 import { db } from './db.ts';
 import { cities, classes, newYorkers, newYorkers2, users } from './tables.ts';
diff --git a/drizzle-orm/type-tests/pg/subquery.ts b/drizzle-orm/type-tests/pg/subquery.ts
index 0af17ccf8..82e30ec86 100644
--- a/drizzle-orm/type-tests/pg/subquery.ts
+++ b/drizzle-orm/type-tests/pg/subquery.ts
@@ -1,7 +1,7 @@
 import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/expressions.ts';
 import { alias, integer, pgTable, serial, text } from '~/pg-core/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { DrizzleTypeError, Equal } from '~/utils.ts';
 import { db } from './db.ts';
 
diff --git a/drizzle-orm/type-tests/pg/tables.ts b/drizzle-orm/type-tests/pg/tables.ts
index 26699bcaf..4a940ebcb 100644
--- a/drizzle-orm/type-tests/pg/tables.ts
+++ b/drizzle-orm/type-tests/pg/tables.ts
@@ -45,7 +45,7 @@ import {
 	pgView,
 	type PgViewWithSelection,
 } from '~/pg-core/view.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { InferInsertModel, InferSelectModel } from '~/table.ts';
 import { db } from './db.ts';
 
diff --git a/drizzle-orm/type-tests/pg/update.ts b/drizzle-orm/type-tests/pg/update.ts
index 187afa147..a667825e0 100644
--- a/drizzle-orm/type-tests/pg/update.ts
+++ b/drizzle-orm/type-tests/pg/update.ts
@@ -3,7 +3,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
 import type { PgUpdate } from '~/pg-core/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 import { users } from './tables.ts';
 
diff --git a/drizzle-orm/type-tests/pg/with.ts b/drizzle-orm/type-tests/pg/with.ts
index 49fc10f3b..1e4dfda99 100644
--- a/drizzle-orm/type-tests/pg/with.ts
+++ b/drizzle-orm/type-tests/pg/with.ts
@@ -2,7 +2,7 @@ import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { gt, inArray } from '~/expressions.ts';
 import { integer, pgTable, serial, text } from '~/pg-core/index.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { db } from './db.ts';
 
 const orders = pgTable('orders', {
diff --git a/drizzle-orm/type-tests/sqlite/delete.ts b/drizzle-orm/type-tests/sqlite/delete.ts
index 91f0376c9..fcc754740 100644
--- a/drizzle-orm/type-tests/sqlite/delete.ts
+++ b/drizzle-orm/type-tests/sqlite/delete.ts
@@ -3,7 +3,7 @@ import { eq } from '~/expressions.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { SQLiteDelete } from '~/sqlite-core/index.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
diff --git a/drizzle-orm/type-tests/sqlite/insert.ts b/drizzle-orm/type-tests/sqlite/insert.ts
index 17f89b600..c4566ae8f 100644
--- a/drizzle-orm/type-tests/sqlite/insert.ts
+++ b/drizzle-orm/type-tests/sqlite/insert.ts
@@ -2,7 +2,7 @@ import type { RunResult } from 'better-sqlite3';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/expressions.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { SQLiteInsert } from '~/sqlite-core/query-builders/insert.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
diff --git a/drizzle-orm/type-tests/sqlite/other.ts b/drizzle-orm/type-tests/sqlite/other.ts
index a544e73af..6dfe8a4c9 100644
--- a/drizzle-orm/type-tests/sqlite/other.ts
+++ b/drizzle-orm/type-tests/sqlite/other.ts
@@ -1,6 +1,6 @@
 import type { RunResult } from 'better-sqlite3';
 import { eq, inArray } from '~/expressions.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
diff --git a/drizzle-orm/type-tests/sqlite/select.ts b/drizzle-orm/type-tests/sqlite/select.ts
index 6693b8e25..196dbc4de 100644
--- a/drizzle-orm/type-tests/sqlite/select.ts
+++ b/drizzle-orm/type-tests/sqlite/select.ts
@@ -21,7 +21,7 @@ import {
 	notLike,
 	or,
 } from '~/expressions.ts';
-import { param, sql } from '~/sql/index.ts';
+import { param, sql } from '~/sql/sql.ts';
 import { alias } from '~/sqlite-core/alias.ts';
 
 import type { Equal } from 'type-tests/utils.ts';
diff --git a/drizzle-orm/type-tests/sqlite/subquery.ts b/drizzle-orm/type-tests/sqlite/subquery.ts
index 87926864e..72b4c165a 100644
--- a/drizzle-orm/type-tests/sqlite/subquery.ts
+++ b/drizzle-orm/type-tests/sqlite/subquery.ts
@@ -1,6 +1,6 @@
 import { Expect } from 'type-tests/utils.ts';
 import { and, eq } from '~/expressions.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { alias, integer, sqliteTable, text } from '~/sqlite-core/index.ts';
 import type { DrizzleTypeError, Equal } from '~/utils.ts';
 import { db } from './db.ts';
diff --git a/drizzle-orm/type-tests/sqlite/tables.ts b/drizzle-orm/type-tests/sqlite/tables.ts
index 0c7269031..d56b5fe09 100644
--- a/drizzle-orm/type-tests/sqlite/tables.ts
+++ b/drizzle-orm/type-tests/sqlite/tables.ts
@@ -1,7 +1,7 @@
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq, gt } from '~/expressions.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import {
 	alias,
 	check,
diff --git a/drizzle-orm/type-tests/sqlite/update.ts b/drizzle-orm/type-tests/sqlite/update.ts
index 6686c836d..aa1f8051f 100644
--- a/drizzle-orm/type-tests/sqlite/update.ts
+++ b/drizzle-orm/type-tests/sqlite/update.ts
@@ -2,7 +2,7 @@ import type { RunResult } from 'better-sqlite3';
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { eq } from '~/expressions.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import type { SQLiteUpdate } from '~/sqlite-core/query-builders/update.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
 import { bunDb, db } from './db.ts';
diff --git a/drizzle-orm/type-tests/sqlite/with.ts b/drizzle-orm/type-tests/sqlite/with.ts
index db8b33d75..94a969dac 100644
--- a/drizzle-orm/type-tests/sqlite/with.ts
+++ b/drizzle-orm/type-tests/sqlite/with.ts
@@ -1,7 +1,7 @@
 import type { Equal } from 'type-tests/utils.ts';
 import { Expect } from 'type-tests/utils.ts';
 import { gt, inArray } from '~/expressions.ts';
-import { sql } from '~/sql/index.ts';
+import { sql } from '~/sql/sql.ts';
 import { integer, sqliteTable, text } from '~/sqlite-core/index.ts';
 import { db } from './db.ts';
 
diff --git a/integration-tests/.gitignore b/integration-tests/.gitignore
index 045655f19..eeff14916 100644
--- a/integration-tests/.gitignore
+++ b/integration-tests/.gitignore
@@ -1,3 +1,5 @@
 .env
 *.db
 trace
+tests/imports/imports.cjs
+tests/imports/imports.mjs
diff --git a/integration-tests/package.json b/integration-tests/package.json
index b14575401..745d1cbe0 100644
--- a/integration-tests/package.json
+++ b/integration-tests/package.json
@@ -23,7 +23,8 @@
       "!tests/relational/**/*",
       "!tests/libsql-batch.test.ts",
       "!tests/d1-batch.test.ts",
-      "!tests/replicas/**/*"
+      "!tests/replicas/**/*",
+      "!tests/imports/**/*"
     ],
     "extensions": {
       "ts": "module"
@@ -52,25 +53,26 @@
     "axios": "^1.4.0",
     "tsx": "^3.12.7",
     "vite": "^4.3.9",
-    "vite-tsconfig-paths": "^4.2.0"
+    "vite-tsconfig-paths": "^4.2.0",
+    "zx": "^7.2.2"
   },
   "dependencies": {
     "@aws-sdk/client-rds-data": "^3.345.0",
     "@aws-sdk/credential-providers": "^3.345.0",
     "@libsql/client": "^0.1.6",
+    "@miniflare/d1": "^2.14.0",
+    "@miniflare/shared": "^2.14.0",
     "@planetscale/database": "^1.7.0",
     "@typescript/analyze-trace": "^0.10.0",
     "@vercel/postgres": "^0.3.0",
     "better-sqlite3": "^8.4.0",
     "dockerode": "^3.3.4",
     "dotenv": "^16.1.4",
-    "drizzle-zod": "workspace:../drizzle-zod/dist",
     "drizzle-typebox": "workspace:../drizzle-typebox/dist",
     "drizzle-valibot": "workspace:../drizzle-valibot/dist",
+    "drizzle-zod": "workspace:../drizzle-zod/dist",
     "express": "^4.18.2",
     "get-port": "^7.0.0",
-    "@miniflare/shared": "^2.14.0",
-    "@miniflare/d1": "^2.14.0",
     "mysql2": "^3.3.3",
     "pg": "^8.11.0",
     "postgres": "^3.3.5",
diff --git a/integration-tests/tests/imports/index.test.ts b/integration-tests/tests/imports/index.test.ts
new file mode 100644
index 000000000..f40420b66
--- /dev/null
+++ b/integration-tests/tests/imports/index.test.ts
@@ -0,0 +1,55 @@
+import { afterAll, expect, it } from 'vitest';
+import 'zx/globals';
+import * as fs from 'fs';
+import path from 'path';
+
+const IMPORTS_FOLDER = 'tests/imports/files';
+
+const folderPath = '../drizzle-orm/dist/package.json';
+const pj = JSON.parse(fs.readFileSync(folderPath, 'utf8'));
+
+if (!fs.existsSync(IMPORTS_FOLDER)) {
+	fs.mkdirSync(IMPORTS_FOLDER);
+}
+
+it('dynamic imports check for cjs and mjs', async () => {
+	const promises: ProcessPromise[] = [];
+	for (const [i, key] of Object.keys(pj['exports']).entries()) {
+		const o1 = path.join('drizzle-orm', key);
+		fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'requ');
+		fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'ire("' + o1 + '");\n', {});
+
+		fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
+		fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
+
+		promises.push(
+			$`node ${IMPORTS_FOLDER}/imports_${i}.cjs`.nothrow(),
+			// $`node ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow(),
+		);
+	}
+	const results = await Promise.all(promises);
+
+	for (const result of results) {
+		expect(result.exitCode, result.message).toBe(0);
+	}
+});
+
+// it('dynamic imports check for mjs', async () => {
+// 	const promises: ProcessPromise[] = [];
+// 	for (const [i, key] of Object.keys(pj['exports']).entries()) {
+// 		const o1 = path.join('drizzle-orm', key);
+// 		fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
+// 		fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
+// 		promises.push($`node ${IMPORTS_FOLDER}/imports_${i}.mjs`.nothrow());
+// 	}
+
+// 	const results = await Promise.all(promises);
+
+// 	for (const result of results) {
+// 		expect(result.exitCode, result.message).toBe(0)
+// 	}
+// });
+
+afterAll(() => {
+	fs.rmdirSync(IMPORTS_FOLDER, { recursive: true });
+});
diff --git a/integration-tests/vitest.config.ts b/integration-tests/vitest.config.ts
index 35b0c9b76..22ffdab10 100644
--- a/integration-tests/vitest.config.ts
+++ b/integration-tests/vitest.config.ts
@@ -4,7 +4,7 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
 	test: {
-		include: ['tests/relational/**/*.test.ts', 'tests/libsql-batch.test.ts', 'tests/d1-batch.test.ts', 'tests/replicas/**/*'],
+		include: ['tests/relational/**/*.test.ts', 'tests/libsql-batch.test.ts', 'tests/d1-batch.test.ts', 'tests/replicas/**/*', 'tests/imports/**/*'],
 		exclude: [
 			...(process.env.SKIP_PLANETSCALE_TESTS ? ['tests/relational/mysql.planetscale.test.ts'] : []),
 			'tests/relational/vercel.test.ts',
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d6f587854..15af08a5e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,4 +1,4 @@
-lockfileVersion: '6.1'
+lockfileVersion: '6.0'
 
 settings:
   autoInstallPeers: true
@@ -413,6 +413,9 @@ importers:
       vite-tsconfig-paths:
         specifier: ^4.2.0
         version: 4.2.0(typescript@5.2.2)(vite@4.3.9)
+      zx:
+        specifier: ^7.2.2
+        version: 7.2.2
 
 packages:
 
@@ -2605,7 +2608,7 @@ packages:
     resolution: {integrity: sha512-MxObHvNl4A69ofaTRU8DFqvgzzv8s9yRtaPPm5gud9HDNvpB3GPQFvNuTWAI59B9huVGV5jXYJwbCsmBsOGYWA==}
     dependencies:
       '@types/jsonfile': 6.1.1
-      '@types/node': 20.2.5
+      '@types/node': 20.8.7
     dev: true
 
   /@types/json-schema@7.0.12:
@@ -2623,7 +2626,7 @@ packages:
   /@types/jsonfile@6.1.1:
     resolution: {integrity: sha512-GSgiRCVeapDN+3pqA35IkQwasaCh/0YFH5dEF6S88iDvEn901DjOeH3/QPY+XYP1DFzDZPvIvfeEgk+7br5png==}
     dependencies:
-      '@types/node': 20.2.5
+      '@types/node': 20.8.7
     dev: true
 
   /@types/mime@3.0.1:
@@ -2637,7 +2640,7 @@ packages:
   /@types/node-fetch@2.6.4:
     resolution: {integrity: sha512-1ZX9fcN4Rvkvgv4E6PAY5WXUFWFcRWxZa3EW83UjycOB9ljJCedb2CupIP4RZMEwF/M3eTcCihbBRgwtGbg5Rg==}
     dependencies:
-      '@types/node': 20.2.5
+      '@types/node': 20.8.7
       form-data: 3.0.1
 
   /@types/node@18.15.10:
@@ -2651,6 +2654,11 @@ packages:
   /@types/node@20.2.5:
     resolution: {integrity: sha512-JJulVEQXmiY9Px5axXHeYGLSjhkZEnD+MDPDGbCbIAbMslkKwmygtZFy1X6s/075Yo94sf8GuSlFfPzysQrWZQ==}
 
+  /@types/node@20.8.7:
+    resolution: {integrity: sha512-21TKHHh3eUHIi2MloeptJWALuCu5H7HQTdTrWIFReA8ad+aggoX+lRes3ex7/FtpC+sVUpFMQ+QTfYr74mruiQ==}
+    dependencies:
+      undici-types: 5.25.3
+
   /@types/normalize-package-data@2.4.1:
     resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==}
     dev: true
@@ -2721,7 +2729,7 @@ packages:
   /@types/ws@8.5.4:
     resolution: {integrity: sha512-zdQDHKUgcX/zBc4GrwsE/7dVdAD8JR4EuiAXiiUhhfyIJXXb2+PrGshFyeXWQPMmmZ2XxgaqclgpIC7eTXc1mg==}
     dependencies:
-      '@types/node': 20.2.5
+      '@types/node': 20.8.7
 
   /@typescript-eslint/eslint-plugin@6.7.3(@typescript-eslint/parser@6.7.3)(eslint@8.50.0)(typescript@5.2.2):
     resolution: {integrity: sha512-vntq452UHNltxsaaN+L9WyuMch8bMd9CqJ3zhzTPXXidwbf5mqqKCVXEuvRZUqLJSTLeWE65lQwyXsRGnXkCTA==}
@@ -5541,7 +5549,7 @@ packages:
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dependencies:
       dir-glob: 3.0.1
-      fast-glob: 3.2.12
+      fast-glob: 3.3.1
       ignore: 5.2.4
       merge2: 1.4.1
       slash: 4.0.0
@@ -8579,6 +8587,9 @@ packages:
       which-boxed-primitive: 1.0.2
     dev: true
 
+  /undici-types@5.25.3:
+    resolution: {integrity: sha512-Ga1jfYwRn7+cP9v8auvEXN1rX3sWqlayd4HP7OKk4mZWylEmu3KzXDUGrQUN6Ol7qo1gPvB2e5gX6udnyEPgdA==}
+
   /undici@5.20.0:
     resolution: {integrity: sha512-J3j60dYzuo6Eevbawwp1sdg16k5Tf768bxYK4TUJRH7cBM4kFCbf3mOnM/0E3vQYXvpxITbbWmBafaDbxLDz3g==}
     engines: {node: '>=12.18'}
@@ -9059,7 +9070,7 @@ packages:
       '@types/node': 18.16.16
       '@types/ps-tree': 1.1.2
       '@types/which': 3.0.0
-      chalk: 5.2.0
+      chalk: 5.3.0
       fs-extra: 11.1.1
       fx: 28.0.0
       globby: 13.1.4

From 3822b1c7d9049c247d2e59e7de7ecc6042276583 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Sun, 5 Nov 2023 17:01:10 +0200
Subject: [PATCH 67/72] Add schema to extractTablesRelationalConfig function

---
 drizzle-orm/src/relations.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/drizzle-orm/src/relations.ts b/drizzle-orm/src/relations.ts
index b4750f794..cc87cf787 100644
--- a/drizzle-orm/src/relations.ts
+++ b/drizzle-orm/src/relations.ts
@@ -275,6 +275,7 @@ export interface TableRelationalConfig {
 	columns: Record<string, Column>;
 	relations: Record<string, Relation>;
 	primaryKey: AnyColumn[];
+	schema?: string;
 }
 
 export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
@@ -435,6 +436,7 @@ export function extractTablesRelationalConfig<
 			tablesConfig[key] = {
 				tsName: key,
 				dbName: value[Table.Symbol.Name],
+				schema: value[Table.Symbol.Schema],
 				columns: value[Table.Symbol.Columns],
 				relations: bufferedRelations?.relations ?? {},
 				primaryKey: bufferedRelations?.primaryKey ?? [],

From f6d20a115e4e40d749a5373759d73270f61a920b Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Sun, 5 Nov 2023 17:17:19 +0200
Subject: [PATCH 68/72] Add 60 sec timeout for vitest

---
 integration-tests/tests/imports/index.test.ts | 4 ++--
 integration-tests/vitest.config.ts            | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/integration-tests/tests/imports/index.test.ts b/integration-tests/tests/imports/index.test.ts
index f40420b66..f89efe00f 100644
--- a/integration-tests/tests/imports/index.test.ts
+++ b/integration-tests/tests/imports/index.test.ts
@@ -19,8 +19,8 @@ it('dynamic imports check for cjs and mjs', async () => {
 		fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'requ');
 		fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.cjs`, 'ire("' + o1 + '");\n', {});
 
-		fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
-		fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
+		// fs.writeFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'imp');
+		// fs.appendFileSync(`${IMPORTS_FOLDER}/imports_${i}.mjs`, 'ort "' + o1 + '"\n', {});
 
 		promises.push(
 			$`node ${IMPORTS_FOLDER}/imports_${i}.cjs`.nothrow(),
diff --git a/integration-tests/vitest.config.ts b/integration-tests/vitest.config.ts
index 22ffdab10..a238ac877 100644
--- a/integration-tests/vitest.config.ts
+++ b/integration-tests/vitest.config.ts
@@ -12,8 +12,8 @@ export default defineConfig({
 		typecheck: {
 			tsconfig: 'tsconfig.json',
 		},
-		testTimeout: 40000,
-		hookTimeout: 40000,
+		testTimeout: 60000,
+		hookTimeout: 60000,
 		// deps: {
 		// 	inline: true,
 		// },

From 99ce57780ce755cbcc3c0758be740d462f842d75 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Sun, 5 Nov 2023 17:25:51 +0200
Subject: [PATCH 69/72] timeout to 100 sec in vitest

---
 integration-tests/vitest.config.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/integration-tests/vitest.config.ts b/integration-tests/vitest.config.ts
index a238ac877..261754895 100644
--- a/integration-tests/vitest.config.ts
+++ b/integration-tests/vitest.config.ts
@@ -12,8 +12,8 @@ export default defineConfig({
 		typecheck: {
 			tsconfig: 'tsconfig.json',
 		},
-		testTimeout: 60000,
-		hookTimeout: 60000,
+		testTimeout: 100000,
+		hookTimeout: 100000,
 		// deps: {
 		// 	inline: true,
 		// },

From d3b1c58856487cc09c3a5e9dc534aa9be9172f11 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Thu, 9 Nov 2023 10:04:30 +0200
Subject: [PATCH 70/72] Update api version to 6

---
 changelogs/drizzle-orm/0.29.0.md | 39 ++++++++++++++++++++++++++++++++
 drizzle-orm/src/version.ts       |  2 +-
 2 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/changelogs/drizzle-orm/0.29.0.md b/changelogs/drizzle-orm/0.29.0.md
index 518c23e33..757fc6bee 100644
--- a/changelogs/drizzle-orm/0.29.0.md
+++ b/changelogs/drizzle-orm/0.29.0.md
@@ -1,3 +1,5 @@
+> Drizzle ORM version `0.29.0` will require a minimum Drizzle Kit version of `0.20.0`, and vice versa. Therefore, when upgrading to a newer version of Drizzle ORM, you will also need to upgrade Drizzle Kit. This may result in some breaking changes throughout the versions, especially if you need to upgrade Drizzle Kit and your Drizzle ORM version is older than `<0.28.0`
+
 ## New Features
 
 ### 🎉 MySQL `unsigned` option for bigint
@@ -110,6 +112,30 @@ const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
 
 `withReplicas` function is available for all dialects in Drizzle ORM
 
+### 🎉 Set operators support (UNION, UNION ALL, INTERSECT, INTERSECT ALL, EXCEPT, EXCEPT ALL)
+
+Huge thanks to @Angelelz for the significant contribution he made, from API discussions to proper type checks and runtime logic, along with an extensive set of tests. This greatly assisted us in delivering this feature in this release
+
+Usage examples:
+All set operators can be used in a two ways: `import approach` or `builder approach`
+
+##### Import approach
+```ts
+import { union } from 'drizzle-orm/pg-core'
+
+const allUsersQuery = db.select().from(users);
+const allCustomersQuery = db.select().from(customers);
+
+const result = await union(allUsersQuery, allCustomersQuery)
+```
+
+##### Builder approach
+```ts
+const result = await db.select().from(users).union(db.select().from(customers));
+```
+
+For more examples for all set operators, please check new section in Drizzle Docs: `Set Operators`
+
 ### 🎉 New MySQL Proxy Driver
 
 A new driver has been released, allowing you to create your own implementation for an HTTP driver using a MySQL database. You can find usage examples in the `./examples/mysql-proxy` folder
@@ -272,3 +298,16 @@ All possible builders that can be used inside `db.batch`:
 ```
 
 More usage examples here: [integration-tests/tests/d1-batch.test.ts](https://github.com/drizzle-team/drizzle-orm/blob/beta/integration-tests/tests/d1-batch.test.ts) and in [docs](https://orm.drizzle.team/docs/batch-api)
+
+---
+## Drizzle Kit 0.20.0
+
+1. New way to define drizzle.config using `defineConfig` function
+2. Possibility to access Claudflare D1 with Drizzle Studio using wrangler.toml file
+3. Drizzle Studio is migrating to https://local.drizzle.studio/
+4. `bigint unsigned` support
+5. `primaryKeys` and `foreignKeys` now can have custom names
+6. Environment variables are now automatically fetched 
+7. Some bug fixes and improvements
+
+You can read more about drizzle-kit updates here: 
\ No newline at end of file
diff --git a/drizzle-orm/src/version.ts b/drizzle-orm/src/version.ts
index 020f2172c..d70a05d15 100644
--- a/drizzle-orm/src/version.ts
+++ b/drizzle-orm/src/version.ts
@@ -1,3 +1,3 @@
 // @ts-ignore - imported using Rollup json plugin
 export { version as npmVersion } from '../package.json';
-export const compatibilityVersion = 5;
+export const compatibilityVersion = 6;

From 4227a46230225f950fca774e884c69d3dee18ec7 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Thu, 9 Nov 2023 20:35:30 +0200
Subject: [PATCH 71/72] Fix changelogs for 0.29.0

---
 changelogs/drizzle-orm/0.29.0.md | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/changelogs/drizzle-orm/0.29.0.md b/changelogs/drizzle-orm/0.29.0.md
index 757fc6bee..6bd473519 100644
--- a/changelogs/drizzle-orm/0.29.0.md
+++ b/changelogs/drizzle-orm/0.29.0.md
@@ -12,6 +12,8 @@ const table = mysqlTable('table', {
 });
 ```
 
+Read more in [docs](https://orm.drizzle.team/docs/column-types/mysql#bigint)
+
 ### 🎉 Improved query builder types
 
 Starting from `0.29.0` by default, as all the query builders in Drizzle try to conform to SQL as much as possible, you can only invoke most of the methods once. For example, in a SELECT statement there might only be one WHERE clause, so you can only invoke .where() once:
@@ -55,6 +57,8 @@ let query = db.select().from(users).where(eq(users.id, 1)).$dynamic();
 query = withFriends(query);
 ```
 
+Read more in [docs](https://orm.drizzle.team/docs/dynamic-query-building)
+
 ### 🎉 Possibility to specify name for primary keys and foreign keys
 
 There is an issue when constraint names exceed the 64-character limit of the database. This causes the database engine to truncate the name, potentially leading to issues. Starting from `0.29.0`, you have the option to specify custom names for both `primaryKey()` and `foreignKey()`. We have also deprecated the old `primaryKey()` syntax, which can still be used but will be removed in future releases
@@ -73,6 +77,8 @@ const table = pgTable('table', {
 }));
 ```
 
+Read more in [docs](https://orm.drizzle.team/docs/indexes-constraints#composite-primary-key)
+
 ### 🎉 Read Replicas Support
 
 You can now use the Drizzle `withReplica` function to specify different database connections for read replicas and the main instance for write operations. By default, `withReplicas` will use a random read replica for read operations and the main instance for all other data modification operations. You can also specify custom logic for choosing which read replica connection to use. You have the freedom to make any weighted, custom decision for that. Here are some usage examples:
@@ -112,6 +118,8 @@ const db = withReplicas(primaryDb, [read1, read2], (replicas) => {
 
 `withReplicas` function is available for all dialects in Drizzle ORM
 
+Read more in [docs](https://orm.drizzle.team/docs/read-replicas)
+
 ### 🎉 Set operators support (UNION, UNION ALL, INTERSECT, INTERSECT ALL, EXCEPT, EXCEPT ALL)
 
 Huge thanks to @Angelelz for the significant contribution he made, from API discussions to proper type checks and runtime logic, along with an extensive set of tests. This greatly assisted us in delivering this feature in this release
@@ -134,7 +142,7 @@ const result = await union(allUsersQuery, allCustomersQuery)
 const result = await db.select().from(users).union(db.select().from(customers));
 ```
 
-For more examples for all set operators, please check new section in Drizzle Docs: `Set Operators`
+Read more in [docs](https://orm.drizzle.team/docs/set-operations)
 
 ### 🎉 New MySQL Proxy Driver
 
@@ -235,7 +243,7 @@ async function main() {
 }
 ```
 
-### 🎉 `D1` batch api support
+### 🎉 `D1` Batch API support
 
 Reference: https://developers.cloudflare.com/d1/platform/client-api/#dbbatch
 
@@ -310,4 +318,4 @@ More usage examples here: [integration-tests/tests/d1-batch.test.ts](https://git
 6. Environment variables are now automatically fetched 
 7. Some bug fixes and improvements
 
-You can read more about drizzle-kit updates here: 
\ No newline at end of file
+You can read more about drizzle-kit updates [here](https://github.com/drizzle-team/drizzle-kit-mirror/releases/tag/v0.20.0)
\ No newline at end of file

From a6dc062017325f4d5e6975b315075497843890e6 Mon Sep 17 00:00:00 2001
From: AndriiSherman <andreysherman11@gmail.com>
Date: Thu, 9 Nov 2023 20:36:27 +0200
Subject: [PATCH 72/72] Fix Cloudflare

---
 changelogs/drizzle-orm/0.29.0.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/changelogs/drizzle-orm/0.29.0.md b/changelogs/drizzle-orm/0.29.0.md
index 6bd473519..18a24e502 100644
--- a/changelogs/drizzle-orm/0.29.0.md
+++ b/changelogs/drizzle-orm/0.29.0.md
@@ -311,7 +311,7 @@ More usage examples here: [integration-tests/tests/d1-batch.test.ts](https://git
 ## Drizzle Kit 0.20.0
 
 1. New way to define drizzle.config using `defineConfig` function
-2. Possibility to access Claudflare D1 with Drizzle Studio using wrangler.toml file
+2. Possibility to access Cloudflare D1 with Drizzle Studio using wrangler.toml file
 3. Drizzle Studio is migrating to https://local.drizzle.studio/
 4. `bigint unsigned` support
 5. `primaryKeys` and `foreignKeys` now can have custom names